home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Linux / Kubuntu 8.10 / kubuntu-8.10-desktop-i386.iso / casper / filesystem.squashfs / etc / bash_completion < prev    next >
Text File  |  2008-06-19  |  217KB  |  9,406 lines
  1. #   bash_completion - programmable completion functions for bash 3.x
  2. #              (backwards compatible with bash 2.05b)
  3. #
  4. #   $Id: bash_completion,v 1.872 2006/03/01 16:20:18 ianmacd Exp $
  5. #
  6. #   Copyright (C) Ian Macdonald <ian@caliban.org>
  7. #
  8. #   This program is free software; you can redistribute it and/or modify
  9. #   it under the terms of the GNU General Public License as published by
  10. #   the Free Software Foundation; either version 2, or (at your option)
  11. #   any later version.
  12. #
  13. #   This program is distributed in the hope that it will be useful,
  14. #   but WITHOUT ANY WARRANTY; without even the implied warranty of
  15. #   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16. #   GNU General Public License for more details.
  17. #
  18. #   You should have received a copy of the GNU General Public License
  19. #   along with this program; if not, write to the Free Software Foundation,
  20. #   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  21. #
  22. #   The latest version of this software can be obtained here:
  23. #
  24. #   http://www.caliban.org/bash/index.shtml#completion
  25. #
  26. #   RELEASE: 20060301
  27.  
  28. if [[ $- == *v* ]]; then
  29.     BASH_COMPLETION_ORIGINAL_V_VALUE="-v"
  30. else
  31.     BASH_COMPLETION_ORIGINAL_V_VALUE="+v"
  32. fi
  33.  
  34. if [[ -n $BASH_COMPLETION_DEBUG ]]; then
  35.     set -v
  36. else
  37.     set +v
  38. fi
  39.  
  40. # Alter the following to reflect the location of this file.
  41. #
  42. [ -n "$BASH_COMPLETION" ] || BASH_COMPLETION=/etc/bash_completion
  43. [ -n "$BASH_COMPLETION_DIR" ] || BASH_COMPLETION_DIR=/etc/bash_completion.d
  44. readonly BASH_COMPLETION BASH_COMPLETION_DIR
  45.  
  46. # Set a couple of useful vars
  47. #
  48. UNAME=$( uname -s )
  49. # strip OS type and version under Cygwin (e.g. CYGWIN_NT-5.1 => Cygwin)
  50. UNAME=${UNAME/CYGWIN_*/Cygwin}
  51. RELEASE=$( uname -r )
  52.  
  53. # features supported by bash 2.05 and higher
  54. if [ ${BASH_VERSINFO[0]} -eq 2 ] && [[ ${BASH_VERSINFO[1]} > 04 ]] ||
  55.    [ ${BASH_VERSINFO[0]} -gt 2 ]; then
  56.     declare -r bash205=$BASH_VERSION 2>/dev/null || :
  57.     default="-o default"
  58.     dirnames="-o dirnames"
  59.     filenames="-o filenames"
  60. fi
  61. # features supported by bash 2.05b and higher
  62. if [ ${BASH_VERSINFO[0]} -eq 2 ] && [[ ${BASH_VERSINFO[1]} = "05b" ]] ||
  63.    [ ${BASH_VERSINFO[0]} -gt 2 ]; then
  64.     declare -r bash205b=$BASH_VERSION 2>/dev/null || :
  65.     nospace="-o nospace"
  66. fi
  67. # features supported by bash 3.0 and higher
  68. if [ ${BASH_VERSINFO[0]} -gt 2 ]; then
  69.     declare -r bash3=$BASH_VERSION 2>/dev/null || :
  70.     bashdefault="-o bashdefault"
  71.     plusdirs="-o plusdirs"
  72. fi
  73.  
  74. # Turn on extended globbing and programmable completion
  75. shopt -s extglob progcomp
  76.  
  77. # A lot of the following one-liners were taken directly from the
  78. # completion examples provided with the bash 2.04 source distribution
  79.  
  80. # Make directory commands see only directories
  81. complete -d pushd
  82.  
  83. # The following section lists completions that are redefined later
  84. # Do NOT break these over multiple lines.
  85. #
  86. # START exclude -- do NOT remove this line
  87. complete -f -X '!*.?(t)bz?(2)' bunzip2 bzcat bzcmp bzdiff bzegrep bzfgrep bzgrep
  88. complete -f -X '!*.@(zip|ZIP|jar|JAR|exe|EXE|pk3|war|wsz|ear|zargo|xpi|sxw|ott)' unzip zipinfo
  89. complete -f -X '*.Z' compress znew
  90. complete -f -X '!*.@(Z|gz|tgz|Gz|dz)' gunzip zcmp zdiff zcat zegrep zfgrep zgrep zless zmore
  91. complete -f -X '!*.Z' uncompress
  92. complete -f -X '!*.@(gif|jp?(e)g|miff|tif?(f)|pn[gm]|p[bgp]m|bmp|xpm|ico|xwd|tga|pcx|GIF|JP?(E)G|MIFF|TIF?(F)|PN[GM]|P[BGP]M|BMP|XPM|ICO|XWD|TGA|PCX)' ee display
  93. complete -f -X '!*.@(gif|jp?(e)g|tif?(f)|png|p[bgp]m|bmp|x[bp]m|rle|rgb|pcx|fits|pm|GIF|JPG|JP?(E)G|TIF?(F)|PNG|P[BGP]M|BMP|X[BP]M|RLE|RGB|PCX|FITS|PM)' xv qiv
  94. complete -f -X '!*.@(@(?(e)ps|?(E)PS|pdf|PDF)?(.gz|.GZ|.bz2|.BZ2|.Z))' gv ggv kghostview
  95. complete -f -X '!*.@(dvi|DVI)?(.@(gz|Z|bz2))' xdvi
  96. complete -f -X '!*.@(dvi|DVI)?(.@(gz|bz2))' kdvi
  97. complete -f -X '!*.@(dvi|DVI)' dvips dviselect dvitype dvipdf advi dvipdfm dvipdfmx
  98. complete -f -X '!*.@(pdf|PDF)' acroread gpdf xpdf
  99. complete -f -X '!*.@(?(e)ps|?(E)PS|pdf|PDF)' kpdf
  100. complete -f -X '!*.@(@(?(e)ps|?(E)PS|pdf|PDF)?(.gz|.GZ)|cb(r|z)|CB(R|Z)|djv?(u)|DJV?(U)||dvi|DVI|gif|jp?(e)g|miff|tif?(f)|pn[gm]|p[bgp]m|bmp|xpm|ico|xwd|tga|pcx|GIF|JP?(E)G|MIFF|TIF?(F)|PN[GM]|P[BGP]M|BMP|XPM|ICO|XWD|TGA|PCX)' evince
  101. complete -f -X '!*.@(?(e)ps|?(E)PS)' ps2pdf
  102. complete -f -X '!*.texi*' makeinfo texi2html
  103. complete -f -X '!*.@(?(la)tex|?(LA)TEX|texi|TEXI|dtx|DTX|ins|INS)' tex latex slitex jadetex pdfjadetex pdftex pdflatex texi2dvi
  104. complete -f -X '!*.@(mp3|MP3)' mpg123 mpg321 madplay
  105. complete -f -X '!*.@(mp?(e)g|MP?(E)G|wma|avi|AVI|asf|vob|VOB|bin|dat|divx|DIVX|vcd|ps|pes|fli|flv|FLV|viv|rm|ram|yuv|mov|MOV|qt|QT|wmv|mp3|MP3|m4p|M4P|m4v|M4V|ogg|OGG|ogm|OGM|mp4|MP4|wav|WAV|asx|ASX|mng|MNG|srt)' xine aaxine fbxine kaffeine
  106. complete -f -X '!*.@(avi|asf|wmv)' aviplay
  107. complete -f -X '!*.@(rm?(j)|ra?(m)|smi?(l))' realplay
  108. complete -f -X '!*.@(mpg|mpeg|avi|mov|qt)' xanim
  109. complete -f -X '!*.@(ogg|OGG|m3u|flac|spx)' ogg123
  110. complete -f -X '!*.@(mp3|MP3|ogg|OGG|pls|m3u)' gqmpeg freeamp
  111. complete -f -X '!*.fig' xfig
  112. complete -f -X '!*.@(mid?(i)|MID?(I))' playmidi
  113. complete -f -X '!*.@(mid?(i)|MID?(I)|rmi|RMI|rcp|RCP|[gr]36|[GR]36|g18|G18|mod|MOD|xm|XM|it|IT|x3m|X3M)' timidity
  114. complete -f -X '*.@(o|so|so.!(conf)|a|rpm|gif|GIF|jp?(e)g|JP?(E)G|mp3|MP3|mp?(e)g|MPG|avi|AVI|asf|ASF|ogg|OGG|class|CLASS)' vi vim gvim rvim view rview rgvim rgview gview
  115. complete -f -X '*.@(o|so|so.!(conf)|a|rpm|gif|GIF|jp?(e)g|JP?(E)G|mp3|MP3|mp?(e)g|MPG|avi|AVI|asf|ASF|ogg|OGG|class|CLASS)' emacs
  116. complete -f -X '!*.@(exe|EXE|com|COM|scr|SCR|exe.so)' wine
  117. complete -f -X '!*.@(zip|ZIP|z|Z|gz|GZ|tgz|TGZ)' bzme
  118. complete -f -X '!*.@(?([xX]|[sS])[hH][tT][mM]?([lL]))' netscape mozilla lynx opera galeon curl dillo elinks amaya
  119. complete -f -X '!*.@(sxw|stw|sxg|sgl|doc|dot|rtf|txt|htm|html|odt|ott|odm)' oowriter
  120. complete -f -X '!*.@(sxi|sti|pps|ppt|pot|odp|otp)' ooimpress
  121. complete -f -X '!*.@(sxc|stc|xls|xlw|xlt|csv|ods|ots)' oocalc
  122. complete -f -X '!*.@(sxd|std|sda|sdd|odg|otg)' oodraw
  123. complete -f -X '!*.@(sxm|smf|mml|odf)' oomath
  124. complete -f -X '!*.odb' oobase
  125. complete -f -X '!*.rpm' rpm2cpio
  126. # FINISH exclude -- do not remove this line
  127.  
  128. # start of section containing compspecs that can be handled within bash
  129.  
  130. # user commands see only users
  131. complete -u su usermod userdel passwd chage write chfn groups slay w sux
  132.  
  133. # group commands see only groups
  134. [ -n "$bash205" ] && complete -g groupmod groupdel newgrp 2>/dev/null
  135.  
  136. # bg completes with stopped jobs
  137. complete -A stopped -P '%' bg
  138.  
  139. # other job commands
  140. complete -j -P '%' fg jobs disown
  141.  
  142. # readonly and unset complete with shell variables
  143. complete -v readonly unset
  144.  
  145. # set completes with set options
  146. complete -A setopt set
  147.  
  148. # shopt completes with shopt options
  149. complete -A shopt shopt
  150.  
  151. # helptopics
  152. complete -A helptopic help
  153.  
  154. # unalias completes with aliases
  155. complete -a unalias
  156.  
  157. # bind completes with readline bindings (make this more intelligent)
  158. complete -A binding bind
  159.  
  160. # type and which complete on commands
  161. complete -c command type which
  162.  
  163. # builtin completes on builtins
  164. complete -b builtin
  165.  
  166. # start of section containing completion functions called by other functions
  167.  
  168. # This function checks whether we have a given program on the system.
  169. # No need for bulky functions in memory if we don't.
  170. #
  171. have()
  172. {
  173.     unset -v have
  174.     PATH=$PATH:/sbin:/usr/sbin:/usr/local/sbin type $1 &>/dev/null &&
  175.         have="yes"
  176. }
  177.  
  178. # use GNU sed if we have it, since its extensions are still used in our code
  179. #
  180. [ $UNAME != Linux ] && have gsed && alias sed=gsed
  181.  
  182. # This function checks whether a given readline variable
  183. # is `on'.
  184. #
  185. _rl_enabled() 
  186. {
  187.     [[ "$( bind -v )" = *$1+([[:space:]])on* ]]
  188. }
  189.  
  190. # This function shell-quotes the argument
  191. quote()
  192. {
  193.     echo \'${1//\'/\'\\\'\'}\' #'# Help vim syntax highlighting
  194. }
  195.  
  196. # This function quotes the argument in a way so that readline dequoting
  197. # results in the original argument
  198. quote_readline()
  199. {
  200.     local t="${1//\\/\\\\}"
  201.     echo \'${t//\'/\'\\\'\'}\' #'# Help vim syntax highlighting
  202. }
  203.  
  204. # This function shell-dequotes the argument
  205. dequote()
  206. {
  207.     eval echo "$1"
  208. }
  209.  
  210.  
  211. # Get the word to complete
  212. # This is nicer than ${COMP_WORDS[$COMP_CWORD]}, since it handles cases
  213. # where the user is completing in the middle of a word.
  214. # (For example, if the line is "ls foobar",
  215. # and the cursor is here -------->   ^
  216. # it will complete just "foo", not "foobar", which is what the user wants.)
  217. #
  218. # Accepts an optional parameter indicating which characters out of
  219. # $COMP_WORDBREAKS should NOT be considered word breaks. This is useful
  220. # for things like scp where we want to return host:path and not only path.
  221. _get_cword()
  222. {
  223.     if [[ "${#COMP_WORDS[COMP_CWORD]}" -eq 0 ]] || [[ "$COMP_POINT" == "${#COMP_LINE}" ]]; then
  224.         echo "${COMP_WORDS[COMP_CWORD]}"
  225.     else
  226.         local i
  227.         local cur="$COMP_LINE"
  228.         local index="$COMP_POINT"
  229.         for (( i = 0; i <= COMP_CWORD; ++i )); do
  230.             while [[ "${#cur}" -ge ${#COMP_WORDS[i]} ]] && [[ "${cur:0:${#COMP_WORDS[i]}}" != "${COMP_WORDS[i]}" ]]; do
  231.                 cur="${cur:1}"
  232.                 index="$(( index - 1 ))"
  233.             done
  234.             if [[ "$i" -lt "$COMP_CWORD" ]]; then
  235.                 local old_size="${#cur}"
  236.                 cur="${cur#${COMP_WORDS[i]}}"
  237.                 local new_size="${#cur}"
  238.                 index="$(( index - old_size + new_size ))"
  239.             fi
  240.         done
  241.  
  242.         if [[ "${COMP_WORDS[COMP_CWORD]:0:${#cur}}" != "$cur" ]]; then
  243.             # We messed up! At least return the whole word so things keep working
  244.             echo "${COMP_WORDS[COMP_CWORD]}"
  245.         else
  246.             echo "${cur:0:$index}"
  247.         fi
  248.     fi
  249. }
  250.  
  251.  
  252. # This function performs file and directory completion. It's better than
  253. # simply using 'compgen -f', because it honours spaces in filenames.
  254. # If passed -d, it completes only on directories. If passed anything else,
  255. # it's assumed to be a file glob to complete on.
  256. #
  257. _filedir()
  258. {
  259.     local IFS=$'\t\n' xspec
  260.  
  261.     _expand || return 0
  262.  
  263.     local toks=( ) tmp
  264.     while read -r tmp; do
  265.         [[ -n $tmp ]] && toks[${#toks[@]}]=$tmp
  266.     done < <( compgen -d -- "$(quote_readline "$cur")" )
  267.  
  268.     if [[ "$1" != -d ]]; then
  269.         xspec=${1:+"!*.$1"}
  270.         while read -r tmp; do
  271.             [[ -n $tmp ]] && toks[${#toks[@]}]=$tmp
  272.         done < <( compgen -f -X "$xspec" -- "$(quote_readline "$cur")" )
  273.     fi
  274.  
  275.     COMPREPLY=( "${COMPREPLY[@]}" "${toks[@]}" )
  276. }
  277.  
  278. # This function completes on signal names
  279. #
  280. _signals()
  281. {
  282.     local i
  283.  
  284.     # standard signal completion is rather braindead, so we need
  285.     # to hack around to get what we want here, which is to
  286.     # complete on a dash, followed by the signal name minus
  287.     # the SIG prefix
  288.     COMPREPLY=( $( compgen -A signal SIG${cur#-} ))
  289.     for (( i=0; i < ${#COMPREPLY[@]}; i++ )); do
  290.         COMPREPLY[i]=-${COMPREPLY[i]#SIG}
  291.     done
  292. }
  293.  
  294. # This function completes on configured network interfaces
  295. #
  296. _configured_interfaces()
  297. {
  298.     if [ -f /etc/debian_version ]; then
  299.         # Debian system
  300.         COMPREPLY=( $( sed -ne 's|^iface \([^ ]\+\).*$|\1|p' \
  301.                    /etc/network/interfaces ) )
  302.     elif [ -f /etc/SuSE-release ]; then
  303.         # SuSE system
  304.         COMPREPLY=( $( command ls \
  305.             /etc/sysconfig/network/ifcfg-* | \
  306.             sed -ne 's|.*ifcfg-\('$cur'.*\)|\1|p' ) )
  307.     elif [ -f /etc/pld-release ]; then
  308.         # PLD Linux
  309.         COMPREPLY=( $( command ls -B \
  310.             /etc/sysconfig/interfaces | \
  311.             sed -ne 's|.*ifcfg-\('$cur'.*\)|\1|p' ) )
  312.     else
  313.         # Assume Red Hat
  314.         COMPREPLY=( $( command ls \
  315.             /etc/sysconfig/network-scripts/ifcfg-* | \
  316.             sed -ne 's|.*ifcfg-\('$cur'.*\)|\1|p' ) )
  317.     fi
  318. }
  319.  
  320. # This function completes on all available network interfaces
  321. # -a: restrict to active interfaces only
  322. # -w: restrict to wireless interfaces only
  323. #
  324. _available_interfaces()
  325. {
  326.     local cmd
  327.  
  328.     if [ "${1:-}" = -w ]; then
  329.         cmd="iwconfig"
  330.     elif [ "${1:-}" = -a ]; then
  331.         cmd="ifconfig"
  332.     else
  333.         cmd="ifconfig -a"
  334.     fi
  335.  
  336.     COMPREPLY=( $( eval $cmd 2>/dev/null | \
  337.         sed -ne 's|^\('$cur'[^[:space:][:punct:]]\{1,\}\).*$|\1|p') )
  338. }
  339.  
  340. # This function expands tildes in pathnames
  341. #
  342. _expand()
  343. {
  344.     # FIXME: Why was this here?
  345.     # [ "$cur" != "${cur%\\}" ] && cur="$cur\\"
  346.  
  347.     # expand ~username type directory specifications
  348.     if [[ "$cur" == \~*/* ]]; then
  349.         eval cur=$cur
  350.     elif [[ "$cur" == \~* ]]; then
  351.         cur=${cur#\~}
  352.         COMPREPLY=( $( compgen -P '~' -u $cur ) )
  353.         return ${#COMPREPLY[@]}
  354.     fi
  355. }
  356.  
  357. # This function completes on process IDs.
  358. # AIX and Solaris ps prefers X/Open syntax.
  359. [ $UNAME = SunOS -o $UNAME = AIX ] &&
  360. _pids()
  361. {
  362.     COMPREPLY=( $( compgen -W '$( command ps -efo pid | sed 1d )' -- $cur ))
  363. } ||
  364. _pids()
  365. {
  366.     COMPREPLY=( $( compgen -W '$( command ps axo pid | sed 1d )' -- $cur ) )
  367. }
  368.  
  369. # This function completes on process group IDs.
  370. # AIX and SunOS prefer X/Open, all else should be BSD.
  371. [ $UNAME = SunOS -o $UNAME = AIX ] &&
  372. _pgids()
  373. {
  374.     COMPREPLY=( $( compgen -W '$( command ps -efo pgid | sed 1d )' -- $cur ))
  375. } ||
  376. _pgids()
  377. {
  378.     COMPREPLY=( $( compgen -W '$( command ps axo pgid | sed 1d )' -- $cur ))
  379. }
  380.  
  381. # This function completes on user IDs
  382. #
  383. _uids()
  384. {
  385.     if type getent &>/dev/null; then
  386.         COMPREPLY=( $( getent passwd | \
  387.                 awk -F: '{if ($3 ~ /^'$cur'/) print $3}' ) )
  388.     elif type perl &>/dev/null; then
  389.         COMPREPLY=( $( compgen -W '$( perl -e '"'"'while (($uid) = (getpwent)[2]) { print $uid . "\n" }'"'"' )' -- $cur ) )
  390.     else
  391.         # make do with /etc/passwd
  392.         COMPREPLY=( $( awk 'BEGIN {FS=":"} {if ($3 ~ /^'$cur'/) print $3}'\
  393.                 /etc/passwd ) )
  394.     fi
  395. }
  396.  
  397. # This function completes on group IDs
  398. #
  399. _gids()
  400. {
  401.     if type getent &>/dev/null; then
  402.         COMPREPLY=( $( getent group | \
  403.                 awk -F: '{if ($3 ~ /^'$cur'/) print $3}' ) )
  404.     elif type perl &>/dev/null; then
  405.         COMPREPLY=( $( compgen -W '$( perl -e '"'"'while (($gid) = (getgrent)[2]) { print $gid . "\n" }'"'"' )' -- $cur ) )
  406.     else
  407.         # make do with /etc/group
  408.         COMPREPLY=( $( awk 'BEGIN {FS=":"} {if ($3 ~ /^'$cur'/) print $3}'\
  409.                 /etc/group ) )
  410.     fi
  411. }
  412.  
  413. # This function completes on services
  414. #
  415. _services()
  416. {
  417.     local sysvdir famdir
  418.     [ -d /etc/rc.d/init.d ] && sysvdir=/etc/rc.d/init.d || sysvdir=/etc/init.d
  419.     famdir=/etc/xinetd.d
  420.     COMPREPLY=( $( builtin echo $sysvdir/!(*.rpmsave|*.rpmorig|*~|functions)) )
  421.  
  422.     if [ -d $famdir ]; then
  423.         COMPREPLY=( "${COMPREPLY[@]}" $( builtin echo $famdir/!(*.rpmsave|*.rpmorig|*~)) )
  424.     fi
  425.  
  426.     COMPREPLY=( $( compgen -W '${COMPREPLY[@]#@($sysvdir|$famdir)/}' -- $cur ) )
  427. }
  428.  
  429. # This function complete on modules
  430. #
  431. _modules()
  432. {
  433.     local modpath
  434.     modpath=/lib/modules/$1
  435.     COMPREPLY=( $( command ls -R $modpath | \
  436.             sed -ne 's/^\('$cur'.*\)\.k\?o\(\|.gz\)$/\1/p') )
  437. }
  438.  
  439. # this function complete on user:group format
  440. #
  441. _usergroup()
  442. {
  443.     local IFS=$'\n'
  444.     cur=${cur//\\\\ / }
  445.     if [[ $cur = *@(\\:|.)* ]] && [ -n "$bash205" ]; then
  446.         user=${cur%%*([^:.])}
  447.         COMPREPLY=( $(compgen -P ${user/\\\\} -g -- ${cur##*[.:]}) )
  448.     elif [[ $cur = *:* ]] && [ -n "$bash205" ]; then
  449.         COMPREPLY=( $( compgen -g -- ${cur##*[.:]} ) )
  450.     else
  451.         COMPREPLY=( $( compgen -S : -u -- $cur ) )
  452.     fi
  453. }
  454.  
  455. # this function count the number of mandatory args
  456. #
  457. _count_args()
  458. {
  459.     args=1
  460.     for (( i=1; i < COMP_CWORD; i++ )); do
  461.         if [[ "${COMP_WORDS[i]}" != -* ]]; then
  462.             args=$(($args+1))
  463.         fi
  464.     done
  465. }
  466.  
  467. # start of section containing completion functions for bash built-ins
  468.  
  469. # bash alias completion
  470. #
  471. _alias()
  472. {
  473.     local cur
  474.  
  475.     COMPREPLY=()
  476.     cur=${COMP_WORDS[$COMP_CWORD]}
  477.  
  478.     case "$COMP_LINE" in
  479.     *[^=])
  480.         COMPREPLY=( $( compgen -A alias -S '=' -- $cur ) )
  481.         ;;
  482.     *=)
  483.         COMPREPLY=( "$( alias ${cur%=} 2>/dev/null | \
  484.                  sed -e 's|^alias '$cur'\(.*\)$|\1|' )" )
  485.         ;;
  486.     esac
  487. }
  488. complete -F _alias $nospace alias
  489.  
  490. # bash export completion
  491. #
  492. _export()
  493. {
  494.     local cur
  495.  
  496.     COMPREPLY=()
  497.     cur=${COMP_WORDS[$COMP_CWORD]}
  498.  
  499.     case "$COMP_LINE" in
  500.     *=\$*)
  501.         COMPREPLY=( $( compgen -v -P '$' -- ${cur#*=\$} ) )
  502.         ;;
  503.     *[^=])
  504.         COMPREPLY=( $( compgen -v -S '=' -- $cur ) )
  505.         ;;
  506.     *=)
  507.         COMPREPLY=( "$( eval echo -n \"$`echo ${cur%=}`\" |
  508.             ( echo -n \'
  509.               sed -e 's/'\''/'\''\\\'\'''\''/g'
  510.               echo -n \' ) )" )
  511.         ;;
  512.     esac
  513. }
  514. complete -F _export $default $nospace export
  515.  
  516. # bash shell function completion
  517. #
  518. _function()
  519. {
  520.     local cur prev
  521.  
  522.     COMPREPLY=()
  523.     cur=`_get_cword`
  524.     prev=${COMP_WORDS[COMP_CWORD-1]}
  525.  
  526.     if [[ $1 == @(declare|typeset) ]]; then
  527.         if [ "$prev" = -f ]; then
  528.             COMPREPLY=( $( compgen -A function -- $cur ) )
  529.         elif [[ "$cur" == -* ]]; then
  530.             COMPREPLY=( $( compgen -W '-a -f -F -i -r -x -p' -- \
  531.                        $cur ) )
  532.         fi
  533.     elif [ $COMP_CWORD -eq 1 ]; then
  534.         COMPREPLY=( $( compgen -A function -- $cur ) )
  535.     else
  536.         COMPREPLY=( "() $( type -- ${COMP_WORDS[1]} | sed -e 1,2d )" )
  537.     fi
  538. }
  539. complete -F _function function declare typeset
  540.  
  541. # bash complete completion
  542. #
  543. _complete()
  544. {
  545.     local cur prev options
  546.  
  547.     COMPREPLY=()
  548.     cur=`_get_cword`
  549.     prev=${COMP_WORDS[COMP_CWORD-1]}
  550.  
  551.     case $prev in
  552.         -o)
  553.             options="default dirnames filenames"
  554.             [ -n "$bash205b" ] && options="$options nospace"
  555.             [ -n "$bash3" ] && options="$options bashdefault plusdirs"
  556.             COMPREPLY=( $( compgen -W "$options" -- $cur ) )
  557.             return 0
  558.             ;;
  559.  
  560.         -A)
  561.             COMPREPLY=( $( compgen -W 'alias arrayvar binding \
  562.                 builtin command directory disabled enabled \
  563.                 export file function group helptopic hostname \
  564.                 job keyword running service setopt shopt \
  565.                 signal stopped user variable' -- $cur ) )
  566.             return 0
  567.             ;;
  568.  
  569.         -C)
  570.             COMPREPLY=( $( compgen -A command -- $cur ) )
  571.             return 0
  572.             ;;
  573.         -F)
  574.             COMPREPLY=( $( compgen -A function -- $cur ) )
  575.             return 0
  576.             ;;
  577.         -@(p|r))
  578.             COMPREPLY=( $( complete -p | sed -e 's|.* ||' | \
  579.                     grep "^$cur" ) )
  580.             return 0
  581.             ;;
  582.  
  583.     esac
  584.  
  585.     if [[ "$cur" == -* ]]; then
  586.         # relevant options completion
  587.         options="-a -b -c -d -e -f -g -j -k -s -v -u -A -G -W -P -S -X -F -C"
  588.         [ -n "$bash205" ] && options="$options -o"
  589.         COMPREPLY=( $( compgen -W "$options" -- $cur ) )
  590.     else
  591.         COMPREPLY=( $( compgen -A command -- $cur ) )
  592.     fi
  593. }
  594. complete -F _complete complete
  595.  
  596. # start of section containing completion functions for external programs
  597.  
  598. # a little help for FreeBSD ports users
  599. [ $UNAME = FreeBSD ] && complete -W 'index search fetch fetch-list \
  600.     extract patch configure build install reinstall \
  601.     deinstall clean clean-depends kernel buildworld' make
  602.  
  603. # This completes on a list of all available service scripts for the
  604. # 'service' command and/or the SysV init.d directory, followed by
  605. # that script's available commands
  606. #
  607. { have service || [ -d /etc/init.d/ ]; } &&
  608. _service()
  609. {
  610.     local cur sysvdir
  611.  
  612.     COMPREPLY=()
  613.     prev=${COMP_WORDS[COMP_CWORD-1]}
  614.     cur=`_get_cword`
  615.  
  616.     # don't complete for things like killall, ssh and mysql if it's
  617.     # the standalone command, rather than the init script
  618.     [[ ${COMP_WORDS[0]} != @(*init.d/!(functions|~)|service) ]] && return 0
  619.  
  620.     # don't complete past 2nd token
  621.     [ $COMP_CWORD -gt 2 ] && return 0
  622.  
  623.     [ -d /etc/rc.d/init.d ] && sysvdir=/etc/rc.d/init.d \
  624.                 || sysvdir=/etc/init.d
  625.  
  626.     if [[ $COMP_CWORD -eq 1 ]] && [[ $prev == "service" ]]; then
  627.         _services
  628.     else
  629.         COMPREPLY=( $( compgen -W '`sed -ne "y/|/ /; \
  630.                 s/^.*Usage.*{\(.*\)}.*$/\1/p" \
  631.                 $sysvdir/${prev##*/} 2>/dev/null`' -- $cur ) )
  632.     fi
  633.  
  634.     return 0
  635. } &&
  636. complete -F _service service
  637. [ -d /etc/init.d/ ] && complete -F _service $default \
  638.     $(for i in /etc/init.d/*; do echo ${i##*/}; done)
  639.  
  640. # chown(1) completion
  641. #
  642. _chown()
  643. {
  644.     local cur
  645.     cur=`_get_cword`
  646.  
  647.     # options completion
  648.     if [[ "$cur" == -* ]]; then
  649.         COMPREPLY=( $( compgen -W '-c -h -f -R -v --changes \
  650.         --dereference --no-dereference --from= --silent --quiet \
  651.         --reference= --recursive --verbose --help --version' -- $cur ) )
  652.     else
  653.         _count_args
  654.  
  655.         case $args in
  656.             1)
  657.                 _usergroup
  658.                 ;;
  659.             *)
  660.                 _filedir
  661.                 ;;
  662.         esac
  663.     fi
  664. }
  665. complete -F _chown $filenames chown
  666.  
  667. # chgrp(1) completion
  668. #
  669. _chgrp()
  670. {
  671.     local cur prev
  672.  
  673.     COMPREPLY=()
  674.     cur=`_get_cword`
  675.     cur=${cur//\\\\/}
  676.     prev=${COMP_WORDS[COMP_CWORD-1]}
  677.  
  678.     # options completion
  679.     if [[ "$cur" == -* ]]; then
  680.         COMPREPLY=( $( compgen -W '-c -h -f -R -v --changes \
  681.         --dereference --no-dereference --silent --quiet \
  682.         --reference= --recursive --verbose --help --version' -- $cur ) )
  683.         return 0
  684.     fi
  685.  
  686.     # first parameter on line or first since an option?
  687.     if [ $COMP_CWORD -eq 1 ] && [[ "$cur" != -* ]] || \
  688.        [[ "$prev" == -* ]] && [ -n "$bash205" ]; then
  689.         local IFS=$'\n'
  690.         COMPREPLY=( $( compgen -g $cur 2>/dev/null ) )
  691.     else
  692.         _filedir || return 0
  693.     fi
  694.  
  695.     return 0
  696. }
  697. complete -F _chgrp $filenames chgrp
  698.  
  699. # umount(8) completion. This relies on the mount point being the third
  700. # space-delimited field in the output of mount(8)
  701. #
  702. _umount()
  703. {
  704.     local cur
  705.  
  706.     COMPREPLY=()
  707.     cur=`_get_cword`
  708.  
  709.     OLDIFS="$IFS"
  710.     IFS="\n"
  711.     COMPREPLY=( $( compgen -W '$( mount | cut -d" " -f 3 )' -- $cur ) )
  712.     IFS="$OLDIFS"
  713.  
  714.     return 0
  715. }
  716. complete -F _umount $dirnames umount
  717.  
  718. # mount(8) completion. This will pull a list of possible mounts out of
  719. # /etc/{,v}fstab, unless the word being completed contains a ':', which
  720. # would indicate the specification of an NFS server. In that case, we
  721. # query the server for a list of all available exports and complete on
  722. # that instead.
  723. #
  724. _mount()
  725. {       local cur i sm host
  726.  
  727.     COMPREPLY=()
  728.     cur=`_get_cword`
  729.     [[ "$cur" == \\ ]] && cur="/"
  730.  
  731.     for i in {,/usr}/{,s}bin/showmount; do [ -x $i ] && sm=$i && break; done
  732.  
  733.     if [ -n "$sm" ] && [[ "$cur" == *:* ]]; then
  734.         COMPREPLY=( $( $sm -e ${cur%%:*} | sed 1d | \
  735.                    grep ^${cur#*:} | awk '{print $1}' ) )
  736.     elif [[ "$cur" == //* ]]; then
  737.         host=${cur#//}
  738.         host=${host%%/*}
  739.         if [ -n "$host" ]; then
  740.             COMPREPLY=( $( compgen -W "$( echo $( smbclient -d 0 -NL $host 2>/dev/null|
  741.             sed -ne '/^['"$'\t '"']*Sharename/,/^$/p' |
  742.             sed -ne '3,$s|^[^A-Za-z]*\([^'"$'\t '"']*\).*$|//'$host'/\1|p' ) )" -- "$cur" ) )
  743.         fi
  744.     elif [ -r /etc/vfstab ]; then
  745.         # Solaris
  746.         COMPREPLY=( $( awk '! /^[ \t]*#/ {if ($3 ~ /\//) print $3}' \
  747.                 /etc/vfstab | grep "^$cur" ) )
  748.     elif [ ! -e /etc/fstab ]; then
  749.         # probably Cygwin
  750.         COMPREPLY=( $( mount | awk '! /^[ \t]*#/ {if ($3 ~ /\//) print $3}' \
  751.                  | grep "^$cur" ) )
  752.     else
  753.         # probably Linux
  754.         COMPREPLY=( $( awk '! /^[ \t]*#/ {if ($2 ~ /\//) print $2}' \
  755.                 /etc/fstab | grep "^$cur" ) )
  756.     fi
  757.  
  758.     return 0
  759. }
  760. complete -F _mount $default $filenames mount
  761.  
  762. # Linux rmmod(8) completion. This completes on a list of all currently
  763. # installed kernel modules.
  764. #
  765. have rmmod && {
  766. _rmmod()
  767. {
  768.     local cur
  769.  
  770.     COMPREPLY=()
  771.     cur=`_get_cword`
  772.  
  773.     COMPREPLY=( $( /sbin/lsmod | \
  774.           awk '{if (NR != 1 && $1 ~ /^'$cur'/) print $1}' 2>/dev/null ))
  775.     return 0
  776. }
  777. complete -F _rmmod rmmod
  778.  
  779. # Linux insmod(8), modprobe(8) and modinfo(8) completion. This completes on a
  780. # list of all available modules for the version of the kernel currently
  781. # running.
  782. #
  783. _insmod()
  784. {
  785.     local cur prev modpath
  786.  
  787.     COMPREPLY=()
  788.     cur=`_get_cword`
  789.     prev=${COMP_WORDS[COMP_CWORD-1]}
  790.  
  791.     # behave like lsmod for modprobe -r
  792.     if [ $1 = "modprobe" ] &&
  793.        [ "${COMP_WORDS[1]}" = "-r" ]; then
  794.         COMPREPLY=( $( /sbin/lsmod | \
  795.                 awk '{if (NR != 1 && $1 ~ /^'$cur'/) print $1}' ) )
  796.         return 0
  797.     fi
  798.  
  799.     # do filename completion if we're giving a path to a module
  800.     if [[ "$cur" == */* ]]; then
  801.         _filedir '@(?(k)o?(.gz))'
  802.         return 0
  803.     fi
  804.  
  805.     if [ $COMP_CWORD -gt 1 ] && 
  806.        [[ "${COMP_WORDS[COMP_CWORD-1]}" != -* ]]; then
  807.         # do module parameter completion
  808.         COMPREPLY=( $( /sbin/modinfo -p ${COMP_WORDS[1]} 2>/dev/null | \
  809.                awk '{if ($1 ~ /^parm:/ && $2 ~ /^'$cur'/) { print $2 } \
  810.             else if ($1 !~ /:/ && $1 ~ /^'$cur'/) { print $1 }}' ) )
  811.     else
  812.         _modules $(uname -r)
  813.     fi
  814.  
  815.     return 0
  816. }
  817. complete -F _insmod $filenames insmod modprobe modinfo
  818. }
  819.  
  820. # man(1) completion
  821. #
  822. [ $UNAME = GNU -o $UNAME = Linux -o $UNAME = Darwin \
  823.   -o $UNAME = FreeBSD -o $UNAME = SunOS -o $UNAME = Cygwin \
  824.   -o $UNAME = OpenBSD ] &&
  825. _man()
  826. {
  827.     local cur prev sect manpath UNAME
  828.  
  829.     COMPREPLY=()
  830.     cur=`_get_cword`
  831.     prev=${COMP_WORDS[COMP_CWORD-1]}
  832.  
  833.     _expand || return 0
  834.  
  835.     # default completion if parameter contains /
  836.     if [[ "$cur" == */* ]]; then
  837.         _filedir
  838.         return 0
  839.     fi
  840.  
  841.     UNAME=$( uname -s )
  842.     # strip OS type and version under Cygwin
  843.     UNAME=${UNAME/CYGWIN_*/Cygwin}
  844.     if [ $UNAME = GNU -o $UNAME = Linux -o $UNAME = FreeBSD \
  845.          -o $UNAME = Cygwin ]; then
  846.         manpath=$( manpath 2>/dev/null || command man --path )
  847.     else
  848.         manpath=$MANPATH
  849.     fi
  850.  
  851.     if [ -z "$manpath" ]; then
  852.         COMPREPLY=( $( compgen -c -- $cur ) )
  853.         return 0
  854.     fi
  855.  
  856.     # determine manual section to search
  857.     [[ "$prev" == [0-9ln] ]] && sect=$prev || sect='*'
  858.  
  859.     manpath=$manpath:
  860.     if [ -n "$cur" ]; then
  861.         manpath="${manpath//://*man$sect/$cur* } ${manpath//://*cat$sect/$cur* }"
  862.     else
  863.         manpath="${manpath//://*man$sect/ } ${manpath//://*cat$sect/ }"
  864.     fi
  865.         
  866.     # redirect stderr for when path doesn't exist
  867.     COMPREPLY=( $( eval command ls "$manpath" 2>/dev/null ) )
  868.     # weed out directory path names and paths to man pages
  869.     COMPREPLY=( ${COMPREPLY[@]##*/?(:)} )
  870.     # strip suffix from man pages
  871.     COMPREPLY=( ${COMPREPLY[@]%.@(gz|bz2)} )
  872.     COMPREPLY=( $( compgen -W '${COMPREPLY[@]%.*}' -- "${cur//\\\\/}" ) )
  873.  
  874.     [[ "$prev" != [0-9ln] ]] && _filedir '[0-9ln]'
  875.  
  876.     return 0
  877. }
  878. [ $UNAME = GNU -o $UNAME = Linux -o $UNAME = Darwin \
  879.   -o $UNAME = FreeBSD -o $UNAME = SunOS -o $UNAME = Cygwin \
  880.   -o $UNAME = OpenBSD ] && \
  881. complete -F _man $filenames man apropos whatis
  882.  
  883. # renice(8) completion
  884. #
  885. _renice()
  886. {
  887.     local command cur curopt i
  888.  
  889.     COMPREPLY=()
  890.     cur=`_get_cword`
  891.     command=$1
  892.  
  893.     i=0
  894.     # walk back through command line and find last option
  895.     while [ $i -le $COMP_CWORD -a ${#COMPREPLY[@]} -eq 0 ]; do
  896.         curopt=${COMP_WORDS[COMP_CWORD-$i]}
  897.         case "$curopt" in
  898.         -u)
  899.             COMPREPLY=( $( compgen -u -- $cur ) )
  900.             ;;
  901.         -g)
  902.             _pgids
  903.             ;;
  904.         -p|$command)
  905.             _pids
  906.             ;;
  907.         esac
  908.         i=$(( ++i ))
  909.     done
  910. }
  911. complete -F _renice renice
  912.  
  913. # kill(1) completion
  914. #
  915. _kill()
  916. {
  917.     local cur
  918.  
  919.     COMPREPLY=()
  920.     cur=`_get_cword`
  921.  
  922.     if [ $COMP_CWORD -eq 1 ] && [[ "$cur" == -* ]]; then
  923.         # return list of available signals
  924.         _signals
  925.     else
  926.         # return list of available PIDs
  927.         _pids
  928.     fi
  929. }
  930. complete -F _kill kill
  931.  
  932. # Linux and FreeBSD killall(1) completion.
  933. #
  934. [ $UNAME = Linux -o $UNAME = FreeBSD ] &&
  935. _killall()
  936. {
  937.     local cur
  938.  
  939.     COMPREPLY=()
  940.     cur=`_get_cword`
  941.  
  942.     if [ $COMP_CWORD -eq 1 ] && [[ "$cur" == -* ]]; then
  943.         _signals
  944.     else
  945.         COMPREPLY=( $( compgen -W '$( command ps axo command | \
  946.                   sed -ne "1d; s/^\[\?\([^-][^] ]*\).*$/\1/p" | \
  947.                   sed -e "s/.*\///" )' -- $cur ) )
  948.     fi
  949.  
  950.     return 0
  951. }
  952. [ $UNAME = Linux -o $UNAME = FreeBSD ] && complete -F _killall killall pkill
  953.  
  954. # Linux and FreeBSD pgrep(1) completion.
  955. #
  956. [ $UNAME = Linux -o $UNAME = FreeBSD ] &&
  957. _pgrep()
  958. {
  959.     local cur
  960.  
  961.     COMPREPLY=()
  962.     cur=`_get_cword`
  963.  
  964.     COMPREPLY=( $( compgen -W '$( command ps axo command | \
  965.               sed -ne "1d; s/^\[\?\([^-][^] ]*\).*$/\1/p" | \
  966.               sed -e "s/.*\///" )' -- $cur ) )
  967.  
  968.     return 0
  969. }
  970. [ $UNAME = Linux -o $UNAME = FreeBSD ] && complete -F _pgrep pgrep
  971. # Linux pidof(8) completion.
  972. [ $UNAME = Linux ] && complete -F _pgrep pidof
  973.  
  974. # GNU find(1) completion. This makes heavy use of ksh style extended
  975. # globs and contains Linux specific code for completing the parameter
  976. # to the -fstype option.
  977. #
  978. _find()
  979. {
  980.     local cur prev i exprfound onlyonce
  981.  
  982.     COMPREPLY=()
  983.     cur=`_get_cword`
  984.     prev=${COMP_WORDS[COMP_CWORD-1]}
  985.  
  986.     case "$prev" in
  987.     -@(max|min)depth)
  988.         COMPREPLY=( $( compgen -W '0 1 2 3 4 5 6 7 8 9' -- $cur ) )
  989.         return 0
  990.         ;;
  991.     -?(a|c)newer|-fls|-fprint?(0|f)|-?(i)?(l)name|-?(i)wholename)
  992.         _filedir
  993.         return 0
  994.         ;;
  995.     -fstype)
  996.         # this is highly non-portable
  997.         [ -e /proc/filesystems ] &&
  998.         COMPREPLY=( $( cut -d$'\t' -f 2 /proc/filesystems | \
  999.                 grep "^$cur" ) )
  1000.         return 0
  1001.         ;;
  1002.     -gid)
  1003.         _gids
  1004.         return 0
  1005.         ;;
  1006.     -group)
  1007.         if [ -n "$bash205" ]; then
  1008.             COMPREPLY=( $( compgen -g -- $cur 2>/dev/null) )
  1009.         fi
  1010.         return 0
  1011.         ;;
  1012.     -?(x)type)
  1013.         COMPREPLY=( $( compgen -W 'b c d p f l s' -- $cur ) )
  1014.         return 0
  1015.         ;;
  1016.     -uid)
  1017.         _uids
  1018.         return 0
  1019.         ;;
  1020.     -user)
  1021.         COMPREPLY=( $( compgen -u -- $cur ) )
  1022.         return 0
  1023.         ;;
  1024.     -exec|-ok)
  1025.         COMP_WORDS=(COMP_WORDS[0] $cur)
  1026.         COMP_CWORD=1
  1027.         _command
  1028.         return 0
  1029.         ;;
  1030.     -[acm]min|-[acm]time|-?(i)?(l)name|-inum|-?(i)path|-?(i)regex| \
  1031.     -links|-perm|-size|-used|-printf)
  1032.         # do nothing, just wait for a parameter to be given
  1033.         return 0
  1034.         ;;
  1035.     esac
  1036.  
  1037.     _expand || return 0
  1038.  
  1039.     # set exprfound to 1 if there is already an expression present
  1040.     for i in ${COMP_WORDS[@]}; do
  1041.         [[ "$i" = [-\(\),\!]* ]] && exprfound=1 && break
  1042.     done
  1043.  
  1044.     # handle case where first parameter is not a dash option
  1045.     if [ "$exprfound" != 1 ] && [[ "$cur" != [-\(\),\!]* ]]; then
  1046.         _filedir -d
  1047.         return 0
  1048.     fi
  1049.  
  1050.     # complete using basic options
  1051.     COMPREPLY=( $( compgen -W '-daystart -depth -follow -help -maxdepth \
  1052.             -mindepth -mount -noleaf -version -xdev -amin -anewer \
  1053.             -atime -cmin -cnewer -ctime -empty -false -fstype \
  1054.             -gid -group -ilname -iname -inum -ipath -iregex \
  1055.             -wholename \
  1056.             -links -lname -mmin -mtime -name -newer -nouser \
  1057.             -nogroup -perm -regex -size -true -type -uid -used \
  1058.             -user -xtype -exec -fls -fprint -fprint0 -fprintf -ok \
  1059.             -print -print0 -printf -prune -ls' -- $cur ) )
  1060.  
  1061.     # this removes any options from the list of completions that have
  1062.     # already been specified somewhere on the command line, as long as
  1063.     # these options can only be used once (in a word, "options", in
  1064.     # opposition to "tests" and "actions", as in the find(1) manpage).
  1065.     onlyonce=' -daystart -depth -follow -help -maxdepth -mindepth -mount \
  1066.            -noleaf -version -xdev '
  1067.     COMPREPLY=( $( echo "${COMP_WORDS[@]}" | \
  1068.                (while read -d ' ' i; do
  1069.                 [ "$i" == "" ] ||
  1070.                 [ "${onlyonce/ ${i%% *} / }" == "$onlyonce" ] &&
  1071.                 continue
  1072.                 # flatten array with spaces on either side,
  1073.                 # otherwise we cannot grep on word boundaries of
  1074.                 # first and last word
  1075.                 COMPREPLY=" ${COMPREPLY[@]} "
  1076.                 # remove word from list of completions
  1077.                 COMPREPLY=( ${COMPREPLY/ ${i%% *} / } )
  1078.             done
  1079.             echo "${COMPREPLY[@]}")
  1080.           ) )
  1081.     
  1082.     _filedir
  1083.     
  1084.     return 0
  1085. }
  1086. complete -F _find $filenames find
  1087.  
  1088. # Linux iwconfig(8) completion
  1089. #
  1090. [ $UNAME = Linux ] && have iwconfig &&
  1091. _iwconfig()
  1092. {
  1093.     local cur prev
  1094.  
  1095.     COMPREPLY=()
  1096.     cur=`_get_cword`
  1097.     prev=${COMP_WORDS[COMP_CWORD-1]}
  1098.     
  1099.     case $prev in
  1100.         mode)
  1101.             COMPREPLY=( $( compgen -W 'managed ad-hoc master \
  1102.                 repeater secondary monitor' -- $cur ) )
  1103.             return 0
  1104.             ;;
  1105.         essid)
  1106.             COMPREPLY=( $( compgen -W 'on off any' -- $cur ) )
  1107.             if [ -n "${COMP_IWLIST_SCAN:-}" ]; then
  1108.                 COMPREPLY=( "${COMPREPLY[@]}" \
  1109.                     $( iwlist ${COMP_WORDS[1]} scan | \
  1110.                     awk -F '"' '/ESSID/ {print $2}' | \
  1111.                     grep "^$cur" ))
  1112.             fi
  1113.             return 0
  1114.             ;;
  1115.         nwid)
  1116.             COMPREPLY=( $( compgen -W 'on off' -- $cur ) )
  1117.             return 0
  1118.             ;;
  1119.         channel)
  1120.             COMPREPLY=( $( iwlist ${COMP_WORDS[1]} channel | \
  1121.                 awk '/^[[:space:]]*Channel/ {print $2}' | \
  1122.                 grep "^$cur" ) )
  1123.             return 0
  1124.             ;;
  1125.  
  1126.         freq)
  1127.             COMPREPLY=( $( iwlist ${COMP_WORDS[1]} channel | \
  1128.                 awk '/^[[:space:]]*Channel/ {print $4"G"}' | \
  1129.                 grep "^$cur" ) )
  1130.             return 0
  1131.             ;;
  1132.         ap)
  1133.             COMPREPLY=( $( compgen -W 'on off any' -- $cur ) )
  1134.             if [ -n "${COMP_IWLIST_SCAN:-}" ]; then
  1135.                 COMPREPLY=( "${COMPREPLY[@]}" \
  1136.                     $( iwlist ${COMP_WORDS[1]} scan | \
  1137.                     awk -F ': ' '/Address/ {print $2}' | \
  1138.                     grep "^$cur" ) )
  1139.             fi
  1140.             return 0
  1141.             ;;
  1142.         rate)
  1143.             COMPREPLY=( $( compgen -W 'auto fixed' -- $cur ) )
  1144.             COMPREPLY=( "${COMPREPLY[@]}" \
  1145.                 $( iwlist ${COMP_WORDS[1]} rate | \
  1146.                 awk '/^[[:space:]]*[0-9]/ {print $1"M"}' | \
  1147.                 grep "^$cur" ) )
  1148.             return 0
  1149.             ;;
  1150.         rts)
  1151.             COMPREPLY=( $( compgen -W 'auto fixed off' -- $cur ) )
  1152.             return 0
  1153.             ;;
  1154.         frag)
  1155.             COMPREPLY=( $( compgen -W 'auto fixed off' -- $cur ) )
  1156.             return 0
  1157.             ;;
  1158.         key)
  1159.             COMPREPLY=( $( compgen -W 'off on open restricted' -- $cur ) )
  1160.             return 0
  1161.             ;;
  1162.         enc)
  1163.             COMPREPLY=( $( compgen -W 'off on open restricted' -- $cur ) )
  1164.             return 0
  1165.             ;;
  1166.         power)
  1167.             COMPREPLY=( $( compgen -W 'period timeout off on' -- $cur ) )
  1168.             return 0
  1169.             ;;
  1170.         txpower)
  1171.             COMPREPLY=( $( compgen -W 'off on auto' -- $cur ) )
  1172.             return 0
  1173.             ;;
  1174.         retry)
  1175.             COMPREPLY=( $( compgen -W 'limit lifetime' -- $cur ) )
  1176.             return 0
  1177.             ;;
  1178.     esac
  1179.  
  1180.     if [ $COMP_CWORD -eq 1 ]; then
  1181.         if [[ "$cur" == -* ]]; then
  1182.             COMPREPLY=( $( compgen -W '--help --version' -- $cur ) ) 
  1183.         else
  1184.             _available_interfaces -w
  1185.         fi
  1186.     else
  1187.         COMPREPLY=( $( compgen -W 'essid nwid mode freq channel sens mode \
  1188.             ap nick rate rts frag enc key power txpower commit' -- $cur ) ) 
  1189.     fi
  1190.  
  1191. } &&
  1192. complete -F _iwconfig iwconfig
  1193.  
  1194. # Linux iwlist(8) completion
  1195. #
  1196. [ $UNAME = Linux ] && have iwlist &&
  1197. _iwlist()
  1198. {
  1199.     local cur prev
  1200.  
  1201.     COMPREPLY=()
  1202.     cur=`_get_cword`
  1203.     prev=${COMP_WORDS[COMP_CWORD-1]}
  1204.     
  1205.     if [ $COMP_CWORD -eq 1 ]; then
  1206.         if [[ "$cur" == -* ]]; then
  1207.             COMPREPLY=( $( compgen -W '--help --version' -- $cur ) ) 
  1208.         else
  1209.             _available_interfaces -w
  1210.         fi
  1211.     else
  1212.         COMPREPLY=( $( compgen -W 'scan scanning freq frequency \
  1213.             channel rate bit bitrate key enc encryption power \
  1214.             txpower retry ap accesspoint peers event' -- $cur ) ) 
  1215.     fi
  1216. } &&
  1217. complete -F _iwlist iwlist
  1218.  
  1219. # Linux iwspy(8) completion
  1220. #
  1221. [ $UNAME = Linux ] && have iwspy &&
  1222. _iwspy()
  1223. {
  1224.     local cur
  1225.  
  1226.     COMPREPLY=()
  1227.     cur=`_get_cword`
  1228.  
  1229.     if [ $COMP_CWORD -eq 1 ]; then
  1230.         if [[ "$cur" == -* ]]; then
  1231.             COMPREPLY=( $( compgen -W '--help --version' -- $cur ) ) 
  1232.         else
  1233.             _available_interfaces -w
  1234.         fi
  1235.     else
  1236.         COMPREPLY=( $( compgen -W 'setthr getthr off' -- $cur ) ) 
  1237.     fi
  1238. } &&
  1239. complete -F _iwspy iwspy
  1240.  
  1241. # Linux iwpriv(8) completion
  1242. #
  1243. [ $UNAME = Linux ] && have iwpriv &&
  1244. _iwpriv()
  1245. {
  1246.     local cur prev
  1247.  
  1248.     COMPREPLY=()
  1249.     cur=`_get_cword`
  1250.     prev=${COMP_WORDS[COMP_CWORD-1]}
  1251.  
  1252.     case "$prev" in
  1253.         roam)
  1254.             COMPREPLY=( $( compgen -W 'on off' -- $cur ) )
  1255.             return 0
  1256.             ;;
  1257.         port)
  1258.             COMPREPLY=( $( compgen -W 'ad-hoc managed' -- $cur ) )
  1259.             return 0
  1260.             ;;
  1261.     esac
  1262.  
  1263.     if [ $COMP_CWORD -eq 1 ]; then
  1264.         if [[ "$cur" == -* ]]; then
  1265.             COMPREPLY=( $( compgen -W '--help --version' -- $cur ) ) 
  1266.         else
  1267.             _available_interfaces -w
  1268.         fi
  1269.     else
  1270.         COMPREPLY=( $( compgen -W '--all roam port' -- $cur ) ) 
  1271.     fi
  1272. } &&
  1273. complete -F _iwpriv iwpriv
  1274.  
  1275. # RedHat & Debian GNU/Linux if{up,down} completion
  1276. #
  1277. [ $UNAME = Linux ] && { have ifup || have ifdown; } &&
  1278. _ifupdown()
  1279. {
  1280.     local cur
  1281.  
  1282.     COMPREPLY=()
  1283.     cur=`_get_cword`
  1284.  
  1285.     if [ $COMP_CWORD -eq 1 ]; then
  1286.         _configured_interfaces
  1287.         COMPREPLY=( $(compgen -W '${COMPREPLY[@]}' -- "$cur") )
  1288.        fi
  1289.  
  1290.        return 0
  1291. } &&
  1292. complete -F _ifupdown ifup ifdown
  1293. [ $UNAME = Linux ] && have ifstatus && complete -F _ifupdown ifstatus
  1294.  
  1295. # Linux ipsec(8) completion (for FreeS/WAN)
  1296. #
  1297. [ $UNAME = Linux ] && have ipsec &&
  1298. _ipsec()
  1299. {
  1300.     local cur
  1301.  
  1302.     COMPREPLY=()
  1303.     cur=`_get_cword`
  1304.  
  1305.     
  1306.     if [ $COMP_CWORD -eq 1 ]; then
  1307.         COMPREPLY=( $( compgen -W 'auto barf eroute klipsdebug look \
  1308.                        manual pluto ranbits rsasigkey \
  1309.                        setup showdefaults showhostkey spi \
  1310.                        spigrp tncfg whack' -- $cur ) )
  1311.         return 0
  1312.     fi
  1313.  
  1314.     case ${COMP_WORDS[1]} in
  1315.     auto)
  1316.         COMPREPLY=( $( compgen -W '--asynchronous --up --add --delete \
  1317.                        --replace --down --route --unroute \
  1318.                        --ready --status --rereadsecrets' \
  1319.                     -- $cur ) )
  1320.         ;;
  1321.     manual)
  1322.         COMPREPLY=( $( compgen -W '--up --down --route --unroute \
  1323.                        --union' -- $cur ) )
  1324.         ;;
  1325.     ranbits)
  1326.         COMPREPLY=( $( compgen -W '--quick --continuous --bytes' \
  1327.                       -- $cur ) )
  1328.         ;;
  1329.     setup)
  1330.         COMPREPLY=( $( compgen -W '--start --stop --restart' -- $cur ) )
  1331.         ;;
  1332.  
  1333.     *)
  1334.         ;;
  1335.     esac
  1336.  
  1337.     return 0
  1338. } &&
  1339. complete -F _ipsec ipsec
  1340.  
  1341. # Postfix completion.
  1342. #
  1343. have postfix && {
  1344. # postfix(1)
  1345. #
  1346. _postfix()
  1347. {
  1348.     local cur prev
  1349.  
  1350.     cur=`_get_cword`
  1351.     prev=${COMP_WORDS[COMP_CWORD-1]}
  1352.  
  1353.     if [[ $cur == '-' ]]; then
  1354.         COMPREPLY=(-c -D -v)
  1355.         return 0
  1356.     fi
  1357.     if [[ $prev == '-c' ]]; then
  1358.         _filedir -d
  1359.         return 0
  1360.     fi
  1361.     if [[ $prev == '-D' ]]; then
  1362.         COMPREPLY=( $( compgen -W 'start' -- "`get_cword`" ) )
  1363.         return 0
  1364.     fi
  1365.     COMPREPLY=( $( compgen -W 'start stop reload abort flush check' -- \
  1366.         "`get_cword`" ) )
  1367. }
  1368. complete -F _postfix postfix
  1369.  
  1370. # postalias(1) and postmap(1)
  1371. #
  1372. _postmap()
  1373. {
  1374.     local cur prev len idx
  1375.  
  1376.     cur=`_get_cword`
  1377.     prev=${COMP_WORDS[COMP_CWORD-1]}
  1378.  
  1379.     if [[ $cur == '-' ]]; then
  1380.         COMPREPLY=(-N -f -i -n -o -p -r -v -w -c -d -q)
  1381.         return 0
  1382.     fi
  1383.     if [[ $prev == '-c' ]]; then
  1384.         _filedir -d
  1385.         return 0
  1386.     fi
  1387.     if [[ $prev == -[dq] ]]; then
  1388.         return 0
  1389.     fi
  1390.  
  1391.     if [[ "$cur" == *:* ]]; then
  1392.                COMPREPLY=( $( compgen -f -- ${cur#*:} ) )
  1393.     else
  1394.         len=${#cur}
  1395.         idx=0
  1396.         for pval in $( /usr/sbin/postconf -m ); do
  1397.             if [[ "$cur" == "${pval:0:$len}" ]]; then
  1398.                 COMPREPLY[$idx]="$pval:"
  1399.                 idx=$(($idx+1))
  1400.             fi
  1401.         done
  1402.         if [[ $idx -eq 0 ]]; then
  1403.             COMPREPLY=( $( compgen -f -- "$cur" ) )
  1404.         fi
  1405.     fi
  1406.     return 0
  1407. }
  1408. complete -F _postmap postmap postalias
  1409.  
  1410. # postcat(1)
  1411. #
  1412. _postcat()
  1413. {
  1414.     local cur prev pval len idx qfile
  1415.  
  1416.     cur=`_get_cword`
  1417.     prev=${COMP_WORDS[COMP_CWORD-1]}
  1418.  
  1419.     if [[ $cur == '-' ]]; then
  1420.         COMPREPLY=(-c -q -v)
  1421.         return 0
  1422.     fi
  1423.     if [[ $prev == '-c' ]]; then
  1424.         _filedir -d
  1425.         return 0
  1426.     fi
  1427.  
  1428.     qfile=0
  1429.     for idx in "${COMP_WORDS[@]}"; do
  1430.         [[ "$idx" = -q ]] && qfile=1 && break
  1431.     done
  1432.     if [[ $qfile == 1 ]]; then
  1433.         len=${#cur}
  1434.         idx=0
  1435.         for pval in $( mailq | \
  1436.             sed -e '1d; $d; /^[^0-9A-Z]\|^$/d; s/[* !].*$//' ); do
  1437.             if [[ "$cur" == "${pval:0:$len}" ]]; then
  1438.                 COMPREPLY[$idx]=$pval
  1439.                 idx=$(($idx+1))
  1440.             fi
  1441.         done
  1442.         return 0
  1443.     else
  1444.         _filedir
  1445.         return 0
  1446.     fi
  1447. }
  1448. complete -F _postcat postcat
  1449.  
  1450. # postconf(1)
  1451. #
  1452. _postconf()
  1453. {
  1454.     local cur prev pval len idx eqext
  1455.  
  1456.     cur=`_get_cword`
  1457.     prev=${COMP_WORDS[COMP_CWORD-1]}
  1458.     if [[ $cur == '-' ]]; then
  1459.         COMPREPLY=(-c -d -e -h -m -l -n -v)
  1460.         return 0
  1461.     fi
  1462.     if [[ $prev == '-c' ]]; then
  1463.         _filedir -d
  1464.         return 0
  1465.     fi
  1466.     if [[ $prev == '-e' ]]; then
  1467.         cur=${cur#[\"\']}
  1468.         eqext='='
  1469.     fi
  1470.     len=${#cur}
  1471.     idx=0
  1472.     for pval in $( /usr/sbin/postconf | cut -d ' ' -f 1 ); do
  1473.         if [[ "$cur" == "${pval:0:$len}" ]]; then
  1474.             COMPREPLY[$idx]="$pval$eqext"
  1475.             idx=$(($idx+1))
  1476.         fi
  1477.     done
  1478.     return 0
  1479. }
  1480. complete -F _postconf postconf
  1481.  
  1482. # postsuper(1)
  1483. #
  1484. _postsuper()
  1485. {
  1486.     local cur prev pval len idx
  1487.  
  1488.     cur=`_get_cword`
  1489.     prev=${COMP_WORDS[COMP_CWORD-1]}
  1490.  
  1491.     if [[ $cur == '-' ]]; then
  1492.         COMPREPLY=(-c -d -h -H -p -r -s -v)
  1493.         return 0
  1494.     fi
  1495.     case $prev in
  1496.     -[dr])
  1497.         len=${#cur}
  1498.         idx=0
  1499.         for pval in $( echo ALL; mailq | \
  1500.             sed -e '1d; $d; /^[^0-9A-Z]\|^$/d; s/[* !].*$//' ); do
  1501.             if [[ "$cur" == "${pval:0:$len}" ]]; then
  1502.                 COMPREPLY[$idx]=$pval
  1503.                 idx=$(($idx+1))
  1504.             fi
  1505.         done
  1506.         return 0
  1507.         ;;
  1508.     -h)
  1509.         len=${#cur}
  1510.         idx=0
  1511.         for pval in $( echo ALL; mailq | \
  1512.             sed -e '1d; $d; /^[^0-9A-Z]\|^$/d; s/[* ].*$//; /!$/d' ); do
  1513.             if [[ "$cur" == "${pval:0:$len}" ]]; then
  1514.                 COMPREPLY[$idx]=$pval
  1515.                 idx=$(($idx+1))
  1516.             fi
  1517.         done
  1518.         return 0
  1519.         ;;
  1520.     -H)
  1521.         len=${#cur}
  1522.         idx=0
  1523.         for pval in $( echo ALL; mailq | \
  1524.             sed -e '1d; $d; /^[^0-9A-Z]\|^$/d; /^[0-9A-Z]*[* ]/d; s/!.*$//' ); do
  1525.             if [[ "$cur" == "${pval:0:$len}" ]]; then
  1526.                 COMPREPLY[$idx]=$pval
  1527.                 idx=$(($idx+1))
  1528.             fi
  1529.         done
  1530.         return 0
  1531.         ;;
  1532.     esac
  1533.     COMPREPLY=( $( compgen -W 'hold incoming active deferred' -- $cur ) )
  1534.     return 0
  1535. }
  1536. complete -F _postsuper postsuper
  1537. }
  1538.  
  1539. # cvs(1) completion
  1540. #
  1541. have cvs && {
  1542. set_prefix()
  1543. {
  1544.     [ -z ${prefix:-} ] || prefix=${cur%/*}/
  1545.     [ -r ${prefix:-}CVS/Entries ] || prefix=""
  1546. }
  1547.  
  1548. get_entries()
  1549. {
  1550.     local IFS=$'\n'
  1551.     [ -r ${prefix:-}CVS/Entries ] && \
  1552.     entries=$(cut -d/ -f2 -s ${prefix:-}CVS/Entries)
  1553. }
  1554.  
  1555. get_modules()
  1556. {
  1557.     if [ -n "$prefix" ]; then 
  1558.         COMPREPLY=( $( command ls -d ${cvsroot}/${prefix}/!(CVSROOT) ) )
  1559.     else
  1560.         COMPREPLY=( $( command ls -d ${cvsroot}/!(CVSROOT) ) )
  1561.     fi
  1562. }
  1563.  
  1564. _cvs()
  1565. {
  1566.     local cur count mode i cvsroot cvsroots pwd
  1567.     local -a flags miss files entries changed newremoved
  1568.  
  1569.     COMPREPLY=()
  1570.     cur=`_get_cword`
  1571.  
  1572.     count=0
  1573.     for i in "${COMP_WORDS[@]}"; do
  1574.         [ $count -eq $COMP_CWORD ] && break
  1575.         # Last parameter was the CVSROOT, now go back to mode selection
  1576.         if [ "${COMP_WORDS[((count))]}" == "$cvsroot" -a "$mode" == "cvsroot" ]; then
  1577.             mode=""
  1578.         fi
  1579.         if [ -z "$mode" ]; then
  1580.             case $i in
  1581.             -d)
  1582.                 mode=cvsroot
  1583.                 cvsroot=${COMP_WORDS[((count+1))]}
  1584.                 ;;
  1585.             @(ad?(d)|new))
  1586.                 mode=add
  1587.                 ;;
  1588.             @(adm?(in)|rcs))
  1589.                 mode=admin
  1590.                 ;;
  1591.             ann?(notate))
  1592.                 mode=annotate
  1593.                 ;;
  1594.             @(checkout|co|get))
  1595.                 mode=checkout
  1596.                 ;;
  1597.             @(com?(mit)|ci))
  1598.                 mode=commit
  1599.                 ;;
  1600.             di?(f?(f)))
  1601.                 mode=diff
  1602.                 ;;
  1603.             ex?(p?(ort)))
  1604.                 mode=export
  1605.                 ;;
  1606.             ?(un)edit)
  1607.                 mode=$i
  1608.                 ;;
  1609.             hi?(s?(tory)))
  1610.                 mode=history
  1611.                 ;;
  1612.             im?(p?(ort)))
  1613.                 mode=import
  1614.                 ;;
  1615.             re?(l?(ease)))
  1616.                 mode=release
  1617.                 ;;
  1618.             ?(r)log)
  1619.                 mode=log
  1620.                 ;;
  1621.             @(rdiff|patch))
  1622.                 mode=rdiff
  1623.                 ;;
  1624.             @(remove|rm|delete))
  1625.                 mode=remove
  1626.                 ;;
  1627.             @(rtag|rfreeze))
  1628.                 mode=rtag
  1629.                 ;;
  1630.             st?(at?(us)))
  1631.                 mode=status
  1632.                 ;;
  1633.             @(tag|freeze))
  1634.                 mode=tag
  1635.                 ;;
  1636.             up?(d?(ate)))
  1637.                 mode=update
  1638.                 ;;
  1639.             *)
  1640.                 ;;
  1641.             esac
  1642.         elif [[ "$i" = -* ]]; then
  1643.             flags=( "${flags[@]}" $i )
  1644.         fi
  1645.         count=$((++count))
  1646.     done
  1647.  
  1648.     case "$mode" in
  1649.     add)
  1650.         if [[ "$cur" != -* ]]; then
  1651.             set_prefix
  1652.             if [ $COMP_CWORD -gt 1 -a -r ${prefix:-}CVS/Entries ]; then
  1653.                 get_entries
  1654.                 [ -z "$cur" ] && \
  1655.                 files=$( command ls -Ad !(CVS) ) || \
  1656.                 files=$( command ls -d ${cur}* 2>/dev/null )
  1657.                 for i in "${entries[@]}"; do
  1658.                     files=( ${files[@]/#$i//} )
  1659.                 done
  1660.                 COMPREPLY=( $( compgen -W '${files[@]}' -- \
  1661.                            $cur ) )
  1662.             fi
  1663.         else
  1664.             COMPREPLY=( $( compgen -W '-k -m' -- $cur ) )
  1665.         fi
  1666.         ;;
  1667.     admin)
  1668.         if [[ "$cur" = -* ]]; then
  1669.             COMPREPLY=( $( compgen -W '-i -a -A -e -b -c -k -l -u \
  1670.                            -L -U -m -M -n -N -o -q -I \
  1671.                            -s -t -t- -T -V -x -z' -- \
  1672.                     $cur ) )
  1673.         fi
  1674.         ;;
  1675.     annotate)
  1676.         if [[ "$cur" = -* ]]; then
  1677.             COMPREPLY=( $( compgen -W '-D -F -f -l -R -r' -- $cur ) )
  1678.         else
  1679.             get_entries
  1680.             COMPREPLY=( $( compgen -W '${entries[@]}' -- $cur ) )
  1681.         fi
  1682.         ;;
  1683.     checkout)
  1684.         if [[ "$cur" != -* ]]; then
  1685.             [ -z "$cvsroot" ] && cvsroot=$CVSROOT
  1686.             COMPREPLY=( $( cvs -d "$cvsroot" co -c 2> /dev/null | \
  1687.                     awk '{print $1}' ) )
  1688.             COMPREPLY=( $( compgen -W '${COMPREPLY[@]}' -- $cur ) )
  1689.         else
  1690.             COMPREPLY=( $( compgen -W '-A -N -P -R -c -f -l -n -p \
  1691.                           -s -r -D -d -k -j' -- $cur ) )
  1692.         fi
  1693.         ;;
  1694.     commit)
  1695.         set_prefix
  1696.  
  1697.         if [[ "$cur" != -* ]] && [ -r ${prefix:-}CVS/Entries ]; then
  1698.             # if $COMP_CVS_REMOTE is not null, 'cvs commit' will
  1699.             # complete on remotely checked-out files (requires
  1700.             # passwordless access to the remote repository
  1701.             if [ -n "${COMP_CVS_REMOTE:-}" ]; then
  1702.                 # this is the least computationally intensive
  1703.                 # way found so far, but other changes
  1704.                 # (something other than changed/removed/new)
  1705.                 # may be missing
  1706.                 changed=( $( cvs -q diff --brief 2>&1 | \
  1707.                 sed -ne 's/^Files [^ ]* and \([^ ]*\) differ$/\1/p' ) )
  1708.                 newremoved=( $( cvs -q diff --brief 2>&1 | \
  1709.                 sed -ne 's/^cvs diff: \([^ ]*\) .*, no comparison available$/\1/p' ) )
  1710.                 COMPREPLY=( $( compgen -W '${changed[@]:-} \
  1711.                            ${newremoved[@]:-}' -- $cur ) )
  1712.             else
  1713.                 _filedir
  1714.             fi
  1715.         else
  1716.             COMPREPLY=( $( compgen -W '-n -R -l -f -F -m -r' -- \
  1717.                        $cur ) )
  1718.         fi
  1719.         ;;
  1720.     cvsroot)
  1721.         if [ -r ~/.cvspass ]; then
  1722.             # Ugly escaping because of bash treating ':' specially
  1723.             cvsroots=$( sed 's/^[^ ]* //; s/:/\\:/g' ~/.cvspass )
  1724.             COMPREPLY=( $( compgen -W '$cvsroots' -- $cur ) )
  1725.         fi
  1726.         ;;
  1727.     export)
  1728.         if [[ "$cur" != -* ]]; then
  1729.             [ -z "$cvsroot" ] && cvsroot=$CVSROOT
  1730.             COMPREPLY=( $( cvs -d "$cvsroot" co -c | awk '{print $1}' ) )
  1731.             COMPREPLY=( $( compgen -W '${COMPREPLY[@]}' -- $cur ) )
  1732.         else
  1733.             COMPREPLY=( $( compgen -W '-N -f -l -R -n \
  1734.                           -r -D -d -k' -- $cur ) )
  1735.         fi
  1736.         ;;
  1737.     diff)
  1738.         if [[ "$cur" == -* ]]; then
  1739.             _longopt diff
  1740.         else
  1741.             get_entries
  1742.             COMPREPLY=( $( compgen -W '${entries[@]:-}' -- $cur ) )
  1743.         fi
  1744.         ;;
  1745.     remove)
  1746.         if [[ "$cur" != -* ]]; then
  1747.             set_prefix
  1748.             if [ $COMP_CWORD -gt 1 -a -r ${prefix:-}CVS/Entries ]; then
  1749.                 get_entries
  1750.                 # find out what files are missing
  1751.                 for i in "${entries[@]}"; do
  1752.                     [ ! -r "$i" ] && miss=( "${miss[@]}" $i )
  1753.                 done
  1754.                 COMPREPLY=( $(compgen -W '${miss[@]:-}' -- $cur) )
  1755.             fi
  1756.         else
  1757.             COMPREPLY=( $( compgen -W '-f -l -R' -- $cur ) )
  1758.         fi
  1759.         ;;
  1760.     import)
  1761.         if [[ "$cur" != -* ]]; then
  1762.             # starts with same algorithm as checkout
  1763.             [ -z "$cvsroot" ] && cvsroot=$CVSROOT
  1764.             prefix=${cur%/*}
  1765.             if [ -r ${cvsroot}/${prefix} ]; then
  1766.                 get_modules
  1767.                 COMPREPLY=( ${COMPREPLY[@]#$cvsroot} )
  1768.                 COMPREPLY=( ${COMPREPLY[@]#\/} )
  1769.             fi
  1770.             pwd=$( pwd )
  1771.             pwd=${pwd##*/}
  1772.             COMPREPLY=( $( compgen -W '${COMPREPLY[@]} $pwd' -- \
  1773.                        $cur ) )
  1774.         else
  1775.             COMPREPLY=( $( compgen -W '-d -k -I -b -m -W' -- $cur ))
  1776.         fi
  1777.         ;;
  1778.     update)
  1779.         if [[ "$cur" = -* ]]; then
  1780.             COMPREPLY=( $( compgen -W '-A -P -C -d -f -l -R -p \
  1781.                            -k -r -D -j -I -W' -- \
  1782.                            $cur ) )
  1783.         fi
  1784.         ;;
  1785.     "")
  1786.         COMPREPLY=( $( compgen -W 'add admin annotate checkout ci co \
  1787.                        commit diff delete edit export \
  1788.                        freeze get history import log new \
  1789.                        patch rcs rdiff release remove \
  1790.                        rfreeze rlog rm rtag stat status \
  1791.                        tag unedit up update -H -Q -q -b \
  1792.                        -d -e -f -l -n -t -r -v -w -x -z \
  1793.                        --help --version' -- $cur ) )
  1794.         ;;
  1795.     *)
  1796.         ;;
  1797.     esac
  1798.     
  1799.     return 0
  1800. }
  1801. complete -F _cvs $default cvs
  1802. }
  1803.  
  1804. have rpm && {
  1805. # helper functions for rpm completion
  1806. #
  1807. _rpm_installed_packages()
  1808. {
  1809.     local ver nodig nosig
  1810.  
  1811.     if [ -r /var/log/rpmpkgs -a \
  1812.         /var/log/rpmpkgs -nt /var/lib/rpm/Packages ]; then
  1813.         # using RHL 7.2 or later - this is quicker than querying the DB
  1814.         COMPREPLY=( $( sed -ne \
  1815.         's|^\('$cur'.*\)-[0-9a-zA-Z._]\+-[0-9a-z.@]\+.*\.rpm$|\1|p' \
  1816.                 /var/log/rpmpkgs ) )
  1817.     else
  1818.         nodig=""
  1819.         nosig=""
  1820.         ver=$(rpm --version)
  1821.         ver=${ver##* }
  1822.       
  1823.         if [[ "$ver" > "4.0.4" ]]; then
  1824.             nodig="--nodigest"
  1825.         fi
  1826.         if [[ "$ver" > "4.0.99" ]]; then
  1827.             nosig="--nosignature"
  1828.         fi
  1829.  
  1830.         COMPREPLY=( $( rpm -qa $nodig $nosig | sed -ne \
  1831.         's|^\('$cur'.*\)-[0-9a-zA-Z._]\+-[0-9a-z.@]\+$|\1|p' ) )
  1832.     fi
  1833. }
  1834.  
  1835. _rpm_groups()
  1836. {
  1837.     local IFS=$'\t'
  1838.     # remove trailing backslash, or grep will complain
  1839.     cur=${cur%"\\"}
  1840.     COMPREPLY=( $( rpm -qa $nodig $nosig --queryformat '%{group}\n' | \
  1841.                grep "^$cur" ) )
  1842.     # backslash escape spaces and translate newlines to tabs
  1843.     COMPREPLY=( $( echo "${COMPREPLY[@]}" | sed 's/ /\\ /g' | tr '\n' '\t' ) )
  1844. }
  1845.  
  1846. # rpm(8) completion
  1847. # 
  1848. _rpm()
  1849. {
  1850.     local cur prev ver nodig nosig
  1851.  
  1852.     COMPREPLY=()
  1853.     cur=`_get_cword`
  1854.     prev=${COMP_WORDS[COMP_CWORD-1]}
  1855.     nodig=""
  1856.     nosig=""
  1857.     ver=$(rpm --version); ver=${ver##* }
  1858.   
  1859.     if [[ "$ver" > "4.0.4" ]]; then
  1860.         nodig="--nodigest"
  1861.     fi
  1862.     if [[ "$ver" > "4.0.99" ]]; then
  1863.         nosig="--nosignature"
  1864.     fi
  1865.  
  1866.     if [ $COMP_CWORD -eq 1 ]; then
  1867.         # first parameter on line
  1868.         case "$cur" in
  1869.         -b*)
  1870.             COMPREPLY=( $( compgen -W '-ba -bb -bc -bi -bl -bp -bs'\
  1871.                        -- $cur ) )
  1872.             ;;
  1873.         -t*)
  1874.             COMPREPLY=( $( compgen -W '-ta -tb -tc -ti -tl -tp -ts'\
  1875.                        -- $cur ) )
  1876.             ;;
  1877.         --*)
  1878.             COMPREPLY=( $( compgen -W '--help --version --initdb \
  1879.             --checksig --recompile --rebuild --resign --addsign \
  1880.             --rebuilddb --showrc --setperms --setugids --tarbuild \
  1881.             --eval --install --upgrade --query --freshen --erase \
  1882.             --verify --querytags --rmsource --rmspec --clean \
  1883.             --import' -- $cur ) )
  1884.             ;;
  1885.         *)
  1886.             COMPREPLY=( $( compgen -W '-b -e -F -i -q -t -U -V' \
  1887.                        -- $cur ) )
  1888.             ;;
  1889.         esac
  1890.  
  1891.     return 0
  1892.     fi
  1893.  
  1894.     case "$prev" in
  1895.     --@(@(db|exclude)path|prefix|relocate|root))
  1896.         _filedir -d
  1897.         return 0
  1898.         ;;
  1899.     --eval)
  1900.         # get a list of macros
  1901.         COMPREPLY=( $( sed -ne 's|^\(%'${cur#\%}'[^ '$'\t'']*\).*$|\1|p' \
  1902.                    /usr/lib/rpm/macros ) )
  1903.         return 0
  1904.         ;;
  1905.     --pipe)
  1906.         COMPREPLY=( $( compgen -c -- $cur ) )
  1907.         return 0
  1908.         ;;
  1909.     --rcfile)
  1910.         _filedir
  1911.         return 0
  1912.         ;;
  1913.     --specfile)
  1914.         # complete on .spec files
  1915.         _filedir spec
  1916.         return 0
  1917.         ;;
  1918.     --whatprovides)
  1919.         if [[ "$cur" == */* ]]; then
  1920.             _filedir
  1921.         else
  1922.         # complete on capabilities
  1923.             COMPREPLY=( $( rpm -qa $nodig $nosig --queryformat \
  1924.                     '%{providename}\n' | grep "^$cur" ) )
  1925.         fi
  1926.         return 0
  1927.         ;;
  1928.     --whatrequires)
  1929.         # complete on capabilities
  1930.         COMPREPLY=( $( rpm -qa $nodig $nosig --queryformat \
  1931.                 '%{requirename}\n' | grep "^$cur" ) )
  1932.         return 0
  1933.         ;;
  1934.     esac
  1935.  
  1936.     case "${COMP_WORDS[1]}" in
  1937.     -@([iFU]*|-install|-freshen|-upgrade))
  1938.         if [[ "$cur" == -* ]]; then
  1939.             COMPREPLY=( $( compgen -W '--percent --force --test \
  1940.             --replacepkgs --replacefiles --root --excludedocs \
  1941.             --includedocs --noscripts --rcfile --ignorearch \
  1942.             --dbpath --prefix --ignoreos --nodeps --allfiles \
  1943.             --ftpproxy --ftpport --justdb --httpproxy --httpport \
  1944.             --noorder --relocate --badreloc --notriggers \
  1945.             --excludepath --ignoresize --oldpackage --define \
  1946.             --eval --pipe --queryformat --repackage --nosuggests \
  1947.             --nodigest --nosignature' -- $cur ) )
  1948.         else
  1949.             _filedir 'rpm'
  1950.         fi
  1951.         ;;
  1952.     -@(e|-erase))
  1953.         if [[ "$cur" == -* ]]; then
  1954.             COMPREPLY=( $( compgen -W '--allmatches --noscripts \
  1955.             --notriggers --nodeps --test --repackage' -- $cur ) )
  1956.         else
  1957.             _rpm_installed_packages
  1958.         fi
  1959.         ;;
  1960.     -@(q*|-query))
  1961.         # check whether we're doing file completion
  1962.         if [ "${COMP_LINE#* -*([^ -])f}" != "$COMP_LINE" ]; then
  1963.             if [[ "$cur" == -* ]]; then
  1964.             COMPREPLY=( $( compgen -W '--scripts --root \
  1965.                 --rcfile --requires --ftpport --ftpproxy \
  1966.                 --httpproxy --httpport --provides --triggers \
  1967.                 --dump --changelog --dbpath \
  1968.                 --last --filesbypkg \
  1969.                 --info --list --state \
  1970.                 --docfiles --configfiles --queryformat \
  1971.                 --conflicts --obsoletes \
  1972.                 --nodigest --nosignature \
  1973.                 --triggerscripts' -- $cur ) )
  1974.             else
  1975.             _filedir
  1976.             fi
  1977.         elif [ "${COMP_LINE#* -*([^ -])g}" != "$COMP_LINE" ]; then
  1978.             _rpm_groups
  1979.         elif [ "${COMP_LINE#* -*([^ -])p}" != "$COMP_LINE" ]; then
  1980.             # uninstalled package completion
  1981.             if [[ "$cur" == -* ]]; then
  1982.                 COMPREPLY=( $( compgen -W '--scripts --root \
  1983.                 --rcfile --whatprovides --whatrequires \
  1984.                 --requires --triggeredby --ftpport --ftpproxy \
  1985.                 --httpproxy --httpport --provides --triggers \
  1986.                 --dump --changelog --dbpath --filesbypkg \
  1987.                 --define --eval --pipe --showrc --info --list \
  1988.                 --state --docfiles --configfiles --queryformat\
  1989.                 --conflicts --obsoletes --nodigest \
  1990.                 --nosignature' -- $cur ) )
  1991.             else
  1992.                 _filedir 'rpm'
  1993.             fi
  1994.         else
  1995.             # installed package completion
  1996.             if [[ "$cur" == -* ]]; then
  1997.                 COMPREPLY=( $( compgen -W '--scripts --root \
  1998.                 --rcfile --whatprovides --whatrequires \
  1999.                 --requires --triggeredby --ftpport --ftpproxy \
  2000.                 --httpproxy --httpport --provides --triggers \
  2001.                 --dump --changelog --dbpath --specfile \
  2002.                 --querybynumber --last --filesbypkg --define \
  2003.                 --eval --pipe --showrc --info --list --state \
  2004.                 --docfiles --configfiles --queryformat \
  2005.                 --conflicts --obsoletes --pkgid --hdrid \
  2006.                 --fileid --tid --nodigest --nosignature \
  2007.                 --triggerscripts' -- $cur ) )
  2008.             elif [ "${COMP_LINE#* -*([^ -])a}" == "$COMP_LINE" ]; then
  2009.                 _rpm_installed_packages
  2010.             fi
  2011.         fi
  2012.         ;;
  2013.     -@(K*|-checksig))
  2014.         if [[ "$cur" == -* ]]; then
  2015.             COMPREPLY=( $( compgen -W '--nopgp --nogpg --nomd5 \
  2016.                     --nodigest --nosignature' -- $cur ) )
  2017.         else
  2018.             _filedir 'rpm'
  2019.         fi
  2020.         ;;
  2021.     -@([Vy]*|-verify))
  2022.         if [[ "$cur" == -* ]]; then
  2023.             COMPREPLY=( $( compgen -W '--root --rcfile --dbpath \
  2024.             --nodeps --nogroup --nolinkto --nomode --nomtime \
  2025.             --nordev --nouser --nofiles --noscripts --nomd5 \
  2026.             --querytags --specfile --whatrequires --whatprovides \
  2027.             --nodigest --nosignature' -- $cur ) )
  2028.         # check whether we're doing file completion
  2029.         elif [ "${COMP_LINE#* -*([^ -])f}" != "$COMP_LINE" ]; then
  2030.             _filedir
  2031.         elif [ "${COMP_LINE#* -*([^ -])g}" != "$COMP_LINE" ]; then
  2032.             _rpm_groups
  2033.         elif [ "${COMP_LINE#* -*([^ -])p}" != "$COMP_LINE" ]; then
  2034.             _filedir 'rpm'
  2035.         else
  2036.             _rpm_installed_packages
  2037.         fi
  2038.         ;;
  2039.     -[bt]*)
  2040.         if [[ "$cur" == -* ]]; then
  2041.             COMPREPLY=( $( compgen -W '--short-circuit --timecheck \
  2042.             --clean --rmsource --rmspec --test --sign --buildroot \
  2043.             --target -- buildarch --buildos --nobuild --nodeps \
  2044.             --nodirtokens' -- $cur ) )
  2045.         elif [[ ${COMP_WORDS[1]} == -b* ]]; then
  2046.             _filedir 'spec'
  2047.         else
  2048.             _filedir '@(tgz|tar.@(gz|bz2))'
  2049.         fi
  2050.         ;;
  2051.     --re@(build|compile))
  2052.         if [[ "$cur" == -* ]]; then
  2053.             COMPREPLY=( $( compgen -W '--nodeps --rmsource \
  2054.               --rmspec --sign --nodirtokens --target' -- $cur ) )
  2055.         else
  2056.             _filedir '?(no)src.rpm'
  2057.         fi
  2058.         ;;
  2059.     --tarbuild)
  2060.         _filedir '@(tgz|tar.@(gz|bz2))'
  2061.         ;;
  2062.     --@(re|add)sign)
  2063.         _filedir 'rpm'
  2064.         ;;
  2065.     --set@(perms|gids))
  2066.         _rpm_installed_packages
  2067.         ;;
  2068.     --@(clean|rms@(ource|pec)))
  2069.         if [[ "$cur" == -* ]]; then
  2070.             COMPREPLY=( $( compgen -W '--clean --rmsource \
  2071.                     --rmspec' -- $cur ) )
  2072.         else
  2073.             _filedir 'spec'
  2074.         fi
  2075.         ;;
  2076.     --@(import|dbpath|root))
  2077.         if [[ "$cur" == -* ]]; then
  2078.             COMPREPLY=( $( compgen -W '--import --dbpath --root' \
  2079.                     -- $cur ) )
  2080.         else
  2081.             _filedir
  2082.         fi
  2083.         ;;
  2084.     esac
  2085.  
  2086.     return 0
  2087. }
  2088. complete -F _rpm $filenames rpm rpmbuild
  2089. }
  2090.  
  2091. # Debian apt-get(8) completion.
  2092. #
  2093. have apt-get &&
  2094. _apt_get()
  2095. {
  2096.     local cur prev special i
  2097.  
  2098.     COMPREPLY=()
  2099.     cur=`_get_cword`
  2100.     prev=${COMP_WORDS[COMP_CWORD-1]}
  2101.  
  2102.     for (( i=0; i < ${#COMP_WORDS[@]}-1; i++ )); do
  2103.         if [[ ${COMP_WORDS[i]} == @(install|remove|purge|source|build-dep) ]]; then
  2104.             special=${COMP_WORDS[i]}
  2105.         fi
  2106.     done
  2107.  
  2108.     if [ -n "$special" ]; then
  2109.         case $special in
  2110.         remove|purge)
  2111.             if [ -f /etc/debian_version ]; then
  2112.                 # Debian system
  2113.                 COMPREPLY=( $( _comp_dpkg_installed_packages \
  2114.                         $cur ) )
  2115.             else
  2116.                 # assume RPM based
  2117.                 _rpm_installed_packages
  2118.             fi
  2119.             return 0
  2120.             ;;
  2121.         *)
  2122.             COMPREPLY=( $( apt-cache pkgnames $cur 2> /dev/null ) )
  2123.             return 0
  2124.             ;;
  2125.  
  2126.         esac
  2127.     fi
  2128.  
  2129.     case "$prev" in
  2130.         -@(c|-config-file))
  2131.               _filedir
  2132.              return 0
  2133.              ;;
  2134.  
  2135.         -@(t|-target-release|-default-release))
  2136.              COMPREPLY=( $( apt-cache policy | \
  2137.                     grep "release.o=Debian,a=$cur" | \
  2138.                     sed -e "s/.*a=\(\w*\).*/\1/" | uniq 2> /dev/null) )
  2139.              return 0
  2140.              ;;
  2141.  
  2142.     esac
  2143.  
  2144.     if [[ "$cur" == -* ]]; then
  2145.  
  2146.         COMPREPLY=( $( compgen -W '-d -f -h -v -m -q -s -y \
  2147.                 -u -t -b -c -o --download-only --fix-broken \
  2148.                 --help --version --ignore-missing \
  2149.                 --fix-missing --no-download --quiet --simulate \
  2150.                 --just-print --dry-run --recon --no-act --yes \
  2151.                 --assume-yes --show-upgraded --only-source \
  2152.                 --compile --build --ignore-hold \
  2153.                 --target-release --no-upgrade --force-yes \
  2154.                 --print-uris --purge --reinstall \
  2155.                 --list-cleanup --default-release \
  2156.                 --trivial-only --no-remove --diff-only \
  2157.                 --tar-only --config-file --option --auto-remove' -- $cur ) )
  2158.     else
  2159.  
  2160.         COMPREPLY=( $( compgen -W 'update upgrade dselect-upgrade \
  2161.                 dist-upgrade install remove purge source \
  2162.                 build-dep check clean autoclean autoremove' \
  2163.                 -- $cur ) )
  2164.  
  2165.     fi
  2166.  
  2167.  
  2168.     return 0
  2169. } &&
  2170. complete -F _apt_get $filenames apt-get
  2171.  
  2172. # Debian apt-cache(8) completion.
  2173. #
  2174. have apt-cache &&
  2175. _apt_cache()
  2176. {
  2177.     local cur prev special i
  2178.  
  2179.     COMPREPLY=()
  2180.     cur=`_get_cword`
  2181.     prev=${COMP_WORDS[COMP_CWORD-1]}
  2182.  
  2183.     
  2184.     if [ "$cur" != show ]; then
  2185.         for (( i=0; i < ${#COMP_WORDS[@]}-1; i++ )); do
  2186.         if [[ ${COMP_WORDS[i]} == @(add|depends|dotty|policy|rdepends|madison|show?(pkg|src|)) ]]; then
  2187.             special=${COMP_WORDS[i]}
  2188.         fi
  2189.         done
  2190.     fi
  2191.  
  2192.  
  2193.     if [ -n "$special" ]; then
  2194.         case $special in
  2195.         add)
  2196.             _filedir
  2197.             return 0
  2198.             ;;
  2199.         
  2200.          *)
  2201.             COMPREPLY=( $( apt-cache pkgnames $cur 2> /dev/null ) )
  2202.             return 0
  2203.             ;;
  2204.         
  2205.         esac
  2206.     fi
  2207.  
  2208.  
  2209.     case "$prev" in
  2210.          -@(c|p|s|-config-file|-@(pkg|src)-cache))
  2211.              _filedir
  2212.              return 0
  2213.              ;;
  2214.          search)
  2215.              if [[ "$cur" != -* ]]; then
  2216.                 return 0
  2217.              fi
  2218.              ;;
  2219.     esac
  2220.  
  2221.     if [[ "$cur" == -* ]]; then
  2222.  
  2223.         COMPREPLY=( $( compgen -W '-h -v -p -s -q -i -f -a -g -c \
  2224.                 -o --help --version --pkg-cache --src-cache \
  2225.                 --quiet --important --full --all-versions \
  2226.                 --no-all-versions --generate --no-generate \
  2227.                 --names-only --all-names --recurse \
  2228.                 --config-file --option' -- $cur ) )
  2229.     else
  2230.  
  2231.         COMPREPLY=( $( compgen -W 'add gencaches show showpkg showsrc \
  2232.                 stats dump dumpavail unmet search search \
  2233.                 depends rdepends pkgnames dotty xvcg \
  2234.                 policy madison' -- $cur ) )
  2235.  
  2236.     fi
  2237.  
  2238.  
  2239.     return 0
  2240. } &&
  2241. complete -F _apt_cache $filenames apt-cache
  2242.  
  2243.  
  2244. # Debian aptitude(1) completion
  2245. #
  2246. have aptitude && {
  2247. have grep-status && {
  2248. _comp_dpkg_hold_packages()
  2249. {
  2250.     grep-status -P -e "^$1" -a -FStatus 'hold' -n -s Package
  2251. }
  2252. } || {
  2253. _comp_dpkg_hold_packages()
  2254. {
  2255.     grep -B 2 'hold' /var/lib/dpkg/status | grep "Package: $1" \
  2256.         | cut -d\  -f2
  2257. }
  2258. }
  2259.  
  2260. _aptitude()
  2261. {
  2262.     local cur dashoptions prev special i
  2263.  
  2264.     COMPREPLY=()
  2265.     cur=`_get_cword`
  2266.     prev=${COMP_WORDS[COMP_CWORD-1]}
  2267.  
  2268.  
  2269.     dashoptions='-S -u -i -h --help --version -s --simulate -d \
  2270.              --download-only -P --prompt -y --assume-yes -F \
  2271.              --display-format -O --sort -w --width -f -r -g \
  2272.              --with-recommends --with-suggests -R -G \
  2273.              --without-recommends --without-suggests -t \
  2274.              --target-release -V --show-versions -D --show-deps\
  2275.              -Z -v --verbose --purge-unused'
  2276.  
  2277.     for (( i=0; i < ${#COMP_WORDS[@]}-1; i++ )); do
  2278.         if [[ ${COMP_WORDS[i]} == @(install|reinstall|hold|unhold|markauto|unmarkauto|dist-upgrade|full-upgrade|download|show|forbid-version|purge|remove|changelog|why|why-not|keep|keep-all) ]]; then
  2279.         special=${COMP_WORDS[i]}
  2280.         fi
  2281.         #exclude some mutually exclusive options
  2282.         [[ ${COMP_WORDS[i]} == '-u' ]] && dashoptions=${dashoptions/-i}
  2283.         [[ ${COMP_WORDS[i]} == '-i' ]] && dashoptions=${dashoptions/-u}
  2284.     done
  2285.  
  2286.     if [[ -n "$special" ]]; then
  2287.        case $special in
  2288.            @(install|hold|markauto|unmarkauto|dist-upgrade|full-upgrade|download|show|changelog|why|why-not))
  2289.            COMPREPLY=( $( apt-cache pkgnames $cur 2> /dev/null ) )
  2290.            return 0
  2291.            ;;
  2292.            @(purge|remove|reinstall|forbid-version))
  2293.              COMPREPLY=( $( _comp_dpkg_installed_packages $cur ) )
  2294.            return 0
  2295.            ;;
  2296.            unhold)
  2297.              COMPREPLY=( $( _comp_dpkg_hold_packages $cur ) )
  2298.            return 0
  2299.            ;;
  2300.  
  2301.        esac
  2302.     fi
  2303.  
  2304.     case $prev in
  2305.         # don't complete anything if these options are found
  2306.         @(autoclean|clean|forget-new|search|upgrade|safe-upgrade|update|keep-all))
  2307.         return 0
  2308.         ;;
  2309.  
  2310.         -S)
  2311.         _filedir
  2312.         return 0
  2313.         ;;
  2314.  
  2315.         -@(t|-target-release|-default-release))
  2316.         COMPREPLY=( $( apt-cache policy | \
  2317.             grep "release.o=Debian,a=$cur" | \
  2318.             sed -e "s/.*a=\(\w*\).*/\1/" | uniq 2> /dev/null ) )
  2319.         return 0
  2320.         ;;
  2321.  
  2322.     esac
  2323.  
  2324.     if [[ "$cur" == -* ]]; then
  2325.         COMPREPLY=( $( compgen -W "$dashoptions" -- $cur ) )
  2326.     else
  2327.         COMPREPLY=( $( compgen -W 'update upgrade safe-upgrade forget-new clean \
  2328.                        autoclean install reinstall remove \
  2329.                        hold unhold purge markauto unmarkauto why why-not \
  2330.                        dist-upgrade full-upgrade download search show \
  2331.                        forbid-version changelog keep-all' -- $cur ) )
  2332.     fi
  2333.  
  2334.  
  2335.     return 0
  2336. }
  2337. complete -F _aptitude $default aptitude
  2338. }
  2339.  
  2340. # Debian apt-build(1) completion.
  2341. #
  2342. have apt-build &&
  2343. _apt_build()
  2344. {
  2345.     local cur prev special i
  2346.  
  2347.     COMPREPLY=()
  2348.     cur=`_get_cword`
  2349.     prev=${COMP_WORDS[COMP_CWORD-1]}
  2350.  
  2351.     for (( i=0; i < ${#COMP_WORDS[@]}-1; i++ )); do
  2352.         if [[ ${COMP_WORDS[i]} == @(install|remove|source|info|clean) ]]; then
  2353.             special=${COMP_WORDS[i]}
  2354.         fi
  2355.     done
  2356.  
  2357.     if [ -n "$special" ]; then
  2358.         case $special in
  2359.         @(install|source|info))
  2360.             COMPREPLY=( $( apt-cache pkgnames $cur 2> /dev/null ) )
  2361.             return 0
  2362.             ;;
  2363.         remove)
  2364.             COMPREPLY=( $( _comp_dpkg_installed_packages \
  2365.                     $cur ) )
  2366.             return 0
  2367.             ;;
  2368.         *)
  2369.             return 0
  2370.             ;;
  2371.         esac
  2372.     fi
  2373.  
  2374.     case "$prev" in
  2375.  
  2376.          --@(patch|build-dir|repository-dir))
  2377.            _filedir
  2378.            return 0
  2379.            ;;
  2380.  
  2381.          -@(h|-help))
  2382.            return 0
  2383.            ;;
  2384.  
  2385.     esac
  2386.  
  2387.     if [[ "$cur" == -* ]]; then
  2388.         COMPREPLY=( $( compgen -W '--help --show-upgraded -u --build-dir \
  2389.                   --repository-dir --build-only \
  2390.                   --build-command --reinstall --rebuild \
  2391.                   --remove-builddep --no-wrapper --purge \
  2392.                   --patch --patch-strip -p --yes -y \
  2393.                   --version -v --no-source' -- $cur ) )
  2394.  
  2395.     else
  2396.         COMPREPLY=( $( compgen -W 'update upgrade install remove \
  2397.                   source dist-upgrade world clean info \
  2398.                   clean-build update-repository ' -- $cur ) )
  2399.     fi
  2400.  
  2401.  
  2402.     return 0
  2403. } &&
  2404. complete -F _apt_build $filenames apt-build
  2405.  
  2406. # chsh(1) completion
  2407. #
  2408. _chsh()
  2409. {
  2410.     local cur prev
  2411.  
  2412.     COMPREPLY=()
  2413.     cur=`_get_cword`
  2414.     prev=${COMP_WORDS[COMP_CWORD-1]}
  2415.  
  2416.     if [ "$prev" = "-s" ]; then
  2417.       if [ -f /etc/debian_version ]; then
  2418.         COMPREPLY=( $( </etc/shells ) )
  2419.       else
  2420.         COMPREPLY=( $( chsh -l | grep "^$cur" ) )
  2421.       fi
  2422.     else
  2423.       COMPREPLY=( $( compgen -u -- $cur ) )
  2424.     fi
  2425.  
  2426.     return 0
  2427. }
  2428. complete -F _chsh chsh
  2429.  
  2430. # chkconfig(8) completion
  2431. #
  2432. have chkconfig &&
  2433. _chkconfig()
  2434. {
  2435.     local cur prev
  2436.  
  2437.     COMPREPLY=()
  2438.     cur=`_get_cword`
  2439.     prev=${COMP_WORDS[COMP_CWORD-1]}
  2440.  
  2441.     case "$prev" in
  2442.     @([1-6]|--@(list|add|del)))
  2443.         _services
  2444.         return 0
  2445.         ;;
  2446.     --level)
  2447.         COMPREPLY=( $( compgen -W '1 2 3 4 5 6' -- $cur ) )
  2448.         return 0
  2449.         ;;
  2450.     esac
  2451.  
  2452.     if [[ "$cur" == -* ]]; then
  2453.         COMPREPLY=( $( compgen -W '--list --add --del --level' -- $cur ) )
  2454.     else
  2455.         if [ $COMP_CWORD -eq 2 -o $COMP_CWORD -eq 4 ]; then
  2456.             COMPREPLY=( $( compgen -W 'on off reset' -- $cur ) )
  2457.         else
  2458.             _services
  2459.         fi
  2460.     fi
  2461. } &&
  2462. complete -F _chkconfig chkconfig
  2463.  
  2464. # This function provides simple user@host completion
  2465. #
  2466. _user_at_host() {
  2467.     local cur
  2468.  
  2469.     COMPREPLY=()
  2470.     cur=`_get_cword`
  2471.  
  2472.     if [[ $cur == *@* ]]; then
  2473.         _known_hosts
  2474.     else
  2475.         COMPREPLY=( $( compgen -u -- "$cur" ) )
  2476.     fi
  2477.  
  2478.     return 0
  2479. }
  2480. shopt -u hostcomplete && complete -F _user_at_host $nospace talk ytalk finger
  2481.  
  2482. # This function performs host completion based on ssh's known_hosts files,
  2483. # defaulting to standard host completion if they don't exist.
  2484. #
  2485. _known_hosts()
  2486. {
  2487.        local cur curd ocur user suffix aliases global_kh user_kh hosts i host
  2488.        local -a kh khd config
  2489.  
  2490.     COMPREPLY=()
  2491.     cur=`_get_cword`
  2492.     ocur=$cur
  2493.  
  2494.     [ "$1" = -a ] || [ "$2" = -a ] && aliases='yes'
  2495.     [ "$1" = -c ] || [ "$2" = -c ] && suffix=':'
  2496.     [[ $cur == *@* ]] && user=${cur%@*}@ && cur=${cur#*@}
  2497.     kh=()
  2498.  
  2499.     # ssh config files
  2500.     [ -r /etc/ssh/ssh_config ] &&
  2501.       config=( "${config[@]}" "/etc/ssh/ssh_config" )
  2502.     [ -r "${HOME}/.ssh/config" ] &&
  2503.       config=( "${config[@]}" "${HOME}/.ssh/config" )
  2504.     [ -r "${HOME}/.ssh2/config" ] &&
  2505.       config=( "${config[@]}" "${HOME}/.ssh2/config" )
  2506.  
  2507.     if [ ${#config[@]} -gt 0 ]; then
  2508.         # expand path (if present) to global known hosts file
  2509.         global_kh=$( eval echo $( sed -ne 's/^[ \t]*[Gg][Ll][Oo][Bb][Aa][Ll][Kk][Nn][Oo][Ww][Nn][Hh][Oo][Ss][Tt][Ss][Ff][Ii][Ll][Ee]['"$'\t '"']*\(.*\)$/\1/p' "${config[@]}" ) )
  2510.         # expand path (if present) to user known hosts file
  2511.         user_kh=$( eval echo $( sed -ne 's/^[ \t]*[Uu][Ss][Ee][Rr][Kk][Nn][Oo][Ww][Nn][Hh][Oo][Ss][Tt][Ss][Ff][Ii][Ll][Ee]['"$'\t '"']*\(.*\)$/\1/p' "${config[@]}" ) )
  2512.     fi
  2513.  
  2514.     # Global known_hosts files
  2515.     [ -r "$global_kh" ] &&
  2516.         kh=( "${kh[@]}" "$global_kh" )
  2517.     [ -r /etc/ssh/ssh_known_hosts ] &&
  2518.         kh=( "${kh[@]}" /etc/ssh/ssh_known_hosts )
  2519.     [ -r /etc/ssh/ssh_known_hosts2 ] &&
  2520.         kh=( "${kh[@]}" /etc/ssh/ssh_known_hosts2 )
  2521.     [ -r /etc/known_hosts ] &&
  2522.         kh=( "${kh[@]}" /etc/known_hosts )
  2523.     [ -r /etc/known_hosts2 ] &&
  2524.         kh=( "${kh[@]}" /etc/known_hosts2 )
  2525.     [ -d /etc/ssh2/knownhosts ] &&
  2526.         khd=( "${khd[@]}" /etc/ssh2/knownhosts/*pub )
  2527.  
  2528.     # User known_hosts files
  2529.     [ -r "$user_kh" ] &&
  2530.         kh=( "${kh[@]}" "$user_kh" )
  2531.     [ -r ~/.ssh/known_hosts ] &&
  2532.         kh=( "${kh[@]}" ~/.ssh/known_hosts )
  2533.     [ -r ~/.ssh/known_hosts2 ] &&
  2534.         kh=( "${kh[@]}" ~/.ssh/known_hosts2 )
  2535.     [ -d ~/.ssh2/hostkeys ] &&
  2536.         khd=( "${khd[@]}" ~/.ssh2/hostkeys/*pub )
  2537.  
  2538.     # If we have known_hosts files to use
  2539.     if [ ${#kh[@]} -gt 0 -o ${#khd[@]} -gt 0 ]; then
  2540.         # Escape slashes and dots in paths for awk
  2541.         cur=${cur//\//\\\/}
  2542.         cur=${cur//\./\\\.}
  2543.         curd=$cur
  2544.  
  2545.         if [[ "$cur" == [0-9]*.* ]]; then
  2546.         # Digits followed by a dot - just search for that
  2547.         cur="^$cur.*"
  2548.         elif [[ "$cur" == [0-9]* ]]; then
  2549.         # Digits followed by no dot - search for digits followed
  2550.         # by a dot
  2551.         cur="^$cur.*\."
  2552.         elif [ -z "$cur" ]; then
  2553.         # A blank - search for a dot or an alpha character
  2554.         cur="[a-z.]"
  2555.         else
  2556.         cur="^$cur"
  2557.         fi
  2558.  
  2559.         if [ ${#kh[@]} -gt 0 ]; then
  2560.  
  2561.         # FS needs to look for a comma separated list
  2562.         COMPREPLY=( $( awk 'BEGIN {FS=","}
  2563.                 /^[^|]/ {for (i=1; i<=2; ++i) { \
  2564.                        gsub(" .*$", "", $i); \
  2565.                        if ($i ~ /'$cur'/) {print $i} \
  2566.                 }}' "${kh[@]}" 2>/dev/null ) )
  2567.         fi
  2568.         if [ ${#khd[@]} -gt 0 ]; then
  2569.         # Needs to look for files called
  2570.         # .../.ssh2/key_22_<hostname>.pub
  2571.         # dont fork any processes, because in a cluster environment, 
  2572.         # there can be hundreds of hostkeys
  2573.         for i in "${khd[@]}" ; do
  2574.             if [[ "$i" == *key_22_$curd*.pub ]] && [ -r "$i" ] ; then
  2575.             host=${i/#*key_22_/}
  2576.             host=${host/%.pub/}
  2577.             COMPREPLY=( "${COMPREPLY[@]}" $host )
  2578.             fi
  2579.         done
  2580.         fi
  2581.  
  2582.         # append any available aliases from config files
  2583.         if [ ${#config[@]} -gt 0 ] && [ -n "$aliases" ]; then
  2584.         local host_aliases=$( sed -ne 's/^[Hh][Oo][Ss][Tt]\([Nn][Aa][Mm][Ee]\)\?['"$'\t '"']\+\([^*?]*\)$/\2/p' "${config[@]}" )
  2585.         hosts=$( compgen -W "$host_aliases" -- $ocur )
  2586.         COMPREPLY=( "${COMPREPLY[@]}" $hosts )
  2587.         fi
  2588.  
  2589.         # Now add results of normal hostname completion
  2590.         COMPREPLY=( "${COMPREPLY[@]}" $( compgen -A hostname -- $ocur ) )
  2591.  
  2592.         # apply suffix
  2593.         for (( i=0; i < ${#COMPREPLY[@]}; i++ )); do
  2594.         COMPREPLY[i]=$user${COMPREPLY[i]}$suffix
  2595.         done
  2596.     else
  2597.         # Just do normal hostname completion
  2598.         COMPREPLY=( $( compgen -A hostname -S "$suffix" -- $cur ) )
  2599.     fi
  2600.  
  2601.     return 0
  2602. }
  2603. complete -F _known_hosts traceroute traceroute6 tracepath tracepath6 \
  2604.     ping ping6 fping fping6 telnet host nslookup rsh rlogin ftp dig ssh-installkeys mtr
  2605.  
  2606. # ssh(1) completion
  2607. #
  2608. have ssh && {
  2609. _ssh()
  2610. {
  2611.     local cur prev
  2612.     local -a config
  2613.  
  2614.     COMPREPLY=()
  2615.     cur=`_get_cword`
  2616.     prev=${COMP_WORDS[COMP_CWORD-1]}
  2617.  
  2618.     case "$prev" in
  2619.     -*c)
  2620.         COMPREPLY=( $( compgen -W 'blowfish 3des 3des-cbc blowfish-cbc \
  2621.                arcfour cast128-cbc' -- $cur ) )
  2622.         ;;
  2623.     -*i)
  2624.         _filedir
  2625.         ;;
  2626.     -*l)
  2627.         COMPREPLY=( $( compgen -u -- $cur ) )
  2628.         ;;
  2629.     *)
  2630.         _known_hosts -a
  2631.  
  2632.         [ $COMP_CWORD -eq 1 ] || \
  2633.         COMPREPLY=( "${COMPREPLY[@]}" $( compgen -c -- $cur ) )
  2634.     esac
  2635.  
  2636.     return 0
  2637. }
  2638. shopt -u hostcomplete && complete -F _ssh ssh slogin sftp xhost autossh
  2639.  
  2640. # scp(1) completion
  2641. #
  2642. _scp()
  2643. {
  2644.     local cur userhost path
  2645.  
  2646.     COMPREPLY=()
  2647.     cur=`_get_cword ":"`
  2648.  
  2649.     _expand || return 0
  2650.  
  2651.     if [[ "$cur" == *:* ]]; then
  2652.         local IFS=$'\t\n'
  2653.         # remove backslash escape from :
  2654.         cur=${cur/\\:/:}
  2655.         userhost=${cur%%?(\\):*}
  2656.         path=${cur#*:}
  2657.         # unescape spaces
  2658.         path=${path//\\\\\\\\ / }
  2659.         if [ -z "$path" ]; then
  2660.             # default to home dir of specified user on remote host
  2661.             path=$(ssh -o 'Batchmode yes' $userhost pwd 2>/dev/null)
  2662.         fi
  2663.         # escape spaces; remove executables, aliases, pipes and sockets;
  2664.         # add space at end of file names
  2665.         COMPREPLY=( $( ssh -o 'Batchmode yes' $userhost \
  2666.                    command ls -aF1d "$path*" 2>/dev/null | \
  2667.                    sed -e "s/[][(){}<>\",:;^&!$&=?\`|\\ ']/\\\\\\\\\\\\&/g" \
  2668.                    -e 's/[*@|=]$//g' -e 's/[^\/]$/& /g' ) )
  2669.         return 0
  2670.     fi
  2671.  
  2672.     [[ "$cur" == */* ]] || _known_hosts -c -a
  2673.         local IFS=$'\t\n'
  2674.         COMPREPLY=( "${COMPREPLY[@]}" $( command ls -aF1d $cur* \
  2675.                 2>/dev/null | sed \
  2676.                 -e "s/[][(){}<>\",:;^&!$&=?\`|\\ ']/\\\\&/g" \
  2677.                 -e 's/[*@|=]$//g' -e 's/[^\/]$/& /g' ) )
  2678.     return 0
  2679. }
  2680. complete -F _scp $nospace scp
  2681. }
  2682.  
  2683. # rsync(1) completion
  2684. #
  2685. have rsync &&
  2686. _rsync()
  2687. {
  2688.     local cur prev shell i userhost path
  2689.  
  2690.     COMPREPLY=()
  2691.     cur=`_get_cword`
  2692.     prev=${COMP_WORDS[COMP_CWORD-1]}
  2693.  
  2694.     _expand || return 0
  2695.  
  2696.     case "$prev" in
  2697.     --@(config|password-file|include-from|exclude-from))
  2698.         _filedir
  2699.         return 0
  2700.         ;;
  2701.     -@(T|-temp-dir|-compare-dest))
  2702.         _filedir -d
  2703.         return 0
  2704.         ;;
  2705.     -@(e|-rsh))
  2706.         COMPREPLY=( $( compgen -W 'rsh ssh' -- $cur ) )
  2707.         return 0
  2708.         ;;
  2709.     esac
  2710.  
  2711.     case "$cur" in
  2712.     -*)
  2713.         COMPREPLY=( $( compgen -W '-v -q  -c -a -r -R -b -u -l -L -H \
  2714.                 -p -o -g -D -t -S -n -W -x -B -e -C -I -T -P \
  2715.                 -z -h -4 -6 --verbose --quiet --checksum \
  2716.                 --archive --recursive --relative --backup \
  2717.                 --backup-dir --suffix= --update --links \
  2718.                 --copy-links --copy-unsafe-links --safe-links \
  2719.                 --hard-links --perms --owner --group --devices\
  2720.                 --times --sparse --dry-run --whole-file \
  2721.                 --no-whole-file --one-file-system \
  2722.                 --block-size= --rsh= --rsync-path= \
  2723.                 --cvs-exclude --existing --ignore-existing \
  2724.                 --delete --delete-excluded --delete-after \
  2725.                 --ignore-errors --max-delete= --partial \
  2726.                 --force --numeric-ids --timeout= \
  2727.                 --ignore-times --size-only --modify-window= \
  2728.                 --temp-dir= --compare-dest= --compress \
  2729.                 --exclude= --exclude-from= --include= \
  2730.                 --include-from= --version --daemon --no-detach\
  2731.                 --address= --config= --port= --blocking-io \
  2732.                 --no-blocking-io --stats --progress \
  2733.                 --log-format= --password-file= --bwlimit= \
  2734.                 --write-batch= --read-batch= --help' -- $cur ))
  2735.         ;;
  2736.     *:*)
  2737.         # find which remote shell is used
  2738.         shell=rsh
  2739.         for (( i=1; i < COMP_CWORD; i++ )); do
  2740.             if [[ "${COMP_WORDS[i]}" == -@(e|-rsh) ]]; then
  2741.                 shell=${COMP_WORDS[i+1]}
  2742.                 break
  2743.             fi
  2744.         done
  2745.         if [[ "$shell" == ssh ]]; then
  2746.             # remove backslash escape from :
  2747.             cur=${cur/\\:/:}
  2748.             userhost=${cur%%?(\\):*}
  2749.             path=${cur#*:}
  2750.             # unescape spaces
  2751.             path=${path//\\\\\\\\ / }
  2752.             if [ -z "$path" ]; then
  2753.                 # default to home dir of specified
  2754.                 # user on remote host
  2755.                 path=$(ssh -o 'Batchmode yes' \
  2756.                     $userhost pwd 2>/dev/null)
  2757.             fi
  2758.             # escape spaces; remove executables, aliases, pipes
  2759.             # and sockets; add space at end of file names
  2760.             COMPREPLY=( $( ssh -o 'Batchmode yes' $userhost \
  2761.                 command ls -aF1d "$path*" 2>/dev/null | \
  2762.                 sed -e 's/ /\\\\\\\ /g' -e 's/[*@|=]$//g' \
  2763.                 -e 's/[^\/]$/& /g' ) )
  2764.         fi
  2765.         ;;
  2766.     *)
  2767.         _known_hosts -c -a
  2768.         _filedir
  2769.         ;;
  2770.     esac
  2771.  
  2772.     return 0
  2773. } &&
  2774. complete -F _rsync $nospace $filenames rsync
  2775.  
  2776. # Linux route(8) completion
  2777. #
  2778. [ $UNAME = Linux ] &&
  2779. _route()
  2780. {
  2781.     local cur prev
  2782.  
  2783.     COMPREPLY=()
  2784.     cur=`_get_cword`
  2785.     prev=${COMP_WORDS[COMP_CWORD-1]}
  2786.  
  2787.     if [ "$prev" = dev ]; then
  2788.         COMPREPLY=( $( ifconfig -a | sed -ne 's|^\('$cur'[^ ]*\).*$|\1|p' ))
  2789.         return 0
  2790.     fi
  2791.  
  2792.     COMPREPLY=( $( compgen -W 'add del -host -net netmask metric mss \
  2793.                    window irtt reject mod dyn reinstate dev \
  2794.                    default gw' -- $cur ) )
  2795.  
  2796.     COMPREPLY=( $( echo " ${COMP_WORDS[@]}" | \
  2797.                (while read -d ' ' i; do
  2798.                [ "$i" == "" ] && continue
  2799.                # flatten array with spaces on either side,
  2800.                # otherwise we cannot grep on word
  2801.                # boundaries of first and last word
  2802.                COMPREPLY=" ${COMPREPLY[@]} "
  2803.                # remove word from list of completions
  2804.                COMPREPLY=( ${COMPREPLY/ $i / } )
  2805.             done
  2806.                echo "${COMPREPLY[@]}")
  2807.           ) )
  2808.     return 0
  2809. }
  2810. [ $UNAME = Linux ] && complete -F _route route
  2811.  
  2812. # GNU make(1) completion
  2813. #
  2814. have make || have gmake || have gnumake || have pmake &&
  2815. _make()
  2816. {
  2817.     local file makef makef_dir="." makef_inc cur prev i
  2818.  
  2819.     COMPREPLY=()
  2820.     cur=`_get_cword`
  2821.     prev=${COMP_WORDS[COMP_CWORD-1]}
  2822.  
  2823.     # --name value style option
  2824.     case $prev in
  2825.         -@(f|o|W))
  2826.             _filedir
  2827.             return 0
  2828.             ;;
  2829.         -@(I|C))
  2830.             _filedir -d
  2831.             return 0
  2832.             ;;
  2833.     esac
  2834.  
  2835.     # --name=value style option
  2836.     if [[ "$cur" == *=* ]]; then
  2837.         prev=${cur/=*/}
  2838.         cur=${cur/*=/}
  2839.         case "$prev" in
  2840.             --@(file|makefile))
  2841.                 _filedir
  2842.                 return 0
  2843.                 ;;
  2844.             --@(directory|include-dir))
  2845.                 _filedir -d
  2846.                 return 0
  2847.                 ;;
  2848.         esac
  2849.     fi
  2850.  
  2851.     if [[ "$cur" == -* ]]; then
  2852.         COMPREPLY=( $( compgen -W '-b -m -B -C -d -e -f -h -i -I\
  2853.             -j -l -k -n -o -p -q -r -R - s -S -t -v -w -W \
  2854.             --always-make --directory= --debug \
  2855.             --environment-overrides --file= --makefile= --help \
  2856.             --ignore-errors --include-dir= --jobs --load-average \
  2857.             --max-load --keep-going --just-print --dry-run \
  2858.             --recon --old-file= --assume-old= --print-data-base \
  2859.             --question --no-builtin-rules --no-builtin-variables \
  2860.             --silent --quiet --no-keep-goind --stop --touch \
  2861.             --version --print-directory --no-print-directory \
  2862.             --what-if= --new-file= --assume-new= \
  2863.             --warn-undefined-variables' -- $cur ) )
  2864.     else
  2865.         # before we check for makefiles, see if a path was specified
  2866.         # with -C
  2867.         for (( i=0; i < ${#COMP_WORDS[@]}; i++ )); do
  2868.             if [[ ${COMP_WORDS[i]} == -C ]]; then
  2869.                 # eval for tilde expansion
  2870.                 eval makef_dir=${COMP_WORDS[i+1]}
  2871.                 break
  2872.             fi
  2873.         done
  2874.  
  2875.         # make reads `GNUmakefile', then `makefile', then `Makefile'
  2876.         if [ -f ${makef_dir}/GNUmakefile ]; then
  2877.             makef=${makef_dir}/GNUmakefile
  2878.         elif [ -f ${makef_dir}/makefile ]; then
  2879.             makef=${makef_dir}/makefile
  2880.         elif [ -f ${makef_dir}/Makefile ]; then
  2881.             makef=${makef_dir}/Makefile
  2882.         else
  2883.             makef=${makef_dir}/*.mk           # local convention
  2884.         fi
  2885.  
  2886.         # before we scan for targets, see if a Makefile name was
  2887.         # specified with -f
  2888.         for (( i=0; i < ${#COMP_WORDS[@]}; i++ )); do
  2889.             if [[ ${COMP_WORDS[i]} == -f ]]; then
  2890.                 # eval for tilde expansion
  2891.                 eval makef=${COMP_WORDS[i+1]}
  2892.                 break
  2893.             fi
  2894.         done
  2895.  
  2896.         [ ! -f $makef ] && return 0
  2897.  
  2898.         # deal with included Makefiles
  2899.          makef_inc=$( grep -E '^-?include' $makef | sed -e "s,^.* ,"$makef_dir"/," )
  2900.  
  2901.          for file in $makef_inc; do
  2902.              [ -f $file ] && makef="$makef $file"
  2903.          done
  2904.  
  2905.         COMPREPLY=( $( awk -F':' '/^[a-zA-Z0-9][^$#\/\t=]*:([^=]|$)/ \
  2906.                 {split($1,A,/ /);for(i in A)print A[i]}' \
  2907.                 $makef 2>/dev/null | command grep "^$cur" ))
  2908.     fi
  2909. } &&
  2910. complete -f -F _make $filenames make gmake gnumake pmake
  2911.  
  2912. # GNU tar(1) completion
  2913. #
  2914. _tar()
  2915. {
  2916.     local cur ext regex tar untar
  2917.  
  2918.     COMPREPLY=()
  2919.     cur=`_get_cword`
  2920.  
  2921.     if [ $COMP_CWORD -eq 1 ]; then
  2922.         COMPREPLY=( $( compgen -W 'c t x u r d A' -- $cur ) )
  2923.         return 0
  2924.     fi
  2925.  
  2926.     case "${COMP_WORDS[1]}" in
  2927.     ?(-)[cr]*f)
  2928.         _filedir
  2929.         return 0
  2930.         ;;
  2931.     +([^IZzjy])f)
  2932.         ext='t@(ar?(.@(Z|gz|bz?(2)))|gz|bz?(2))'
  2933.         regex='t\(ar\(\.\(Z\|gz\|bz2\?\)\)\?\|gz\|bz2\?\)'
  2934.         ;;
  2935.     *[Zz]*f)
  2936.         ext='t?(ar.)@(gz|Z)'
  2937.         regex='t\(ar\.\)\?\(gz\|Z\)'
  2938.         ;;
  2939.     *[Ijy]*f)
  2940.         ext='t?(ar.)bz?(2)'
  2941.         regex='t\(ar\.\)\?bz2\?'
  2942.         ;;
  2943.     *)
  2944.         _filedir
  2945.         return 0
  2946.         ;;
  2947.         
  2948.     esac
  2949.  
  2950.     if [[ "$COMP_LINE" == *$ext' ' ]]; then
  2951.         # complete on files in tar file
  2952.         #
  2953.         # get name of tar file from command line
  2954.         tar=$( echo "$COMP_LINE" | \
  2955.             sed -e 's/^.* \([^ ]*'$regex'\) .*$/\1/' )
  2956.         # devise how to untar and list it
  2957.         untar=t${COMP_WORDS[1]//[^Izjyf]/}
  2958.  
  2959.         COMPREPLY=( $( compgen -W "$( echo $( tar $untar $tar \
  2960.                 2>/dev/null ) )" -- "$cur" ) )
  2961.         return 0
  2962.     fi
  2963.  
  2964.     # file completion on relevant files
  2965.     _filedir "$ext"
  2966.  
  2967.     return 0
  2968. }
  2969. [ -n "${COMP_TAR_INTERNAL_PATHS:-}" ] && complete -F _tar $dirnames tar ||
  2970.     complete -F _tar $filenames tar
  2971.  
  2972. # jar(1) completion
  2973. #
  2974. have jar &&
  2975. _jar()
  2976. {
  2977.     local cur
  2978.  
  2979.     COMPREPLY=()
  2980.     cur=`_get_cword`
  2981.  
  2982.     if [ $COMP_CWORD = 1 ]; then
  2983.         COMPREPLY=( $( compgen -W 'c t x u' -- $cur ) )
  2984.         return 0
  2985.     fi
  2986.  
  2987.     case "${COMP_WORDS[1]}" in
  2988.         *c*f)
  2989.             _filedir
  2990.             ;;
  2991.         *f)
  2992.             _filedir '?(e|j|w)ar'
  2993.             ;;
  2994.         *)
  2995.             _filedir
  2996.             ;;
  2997.     esac
  2998. } &&
  2999. complete -F _jar $filenames jar
  3000.  
  3001. # Linux iptables(8) completion
  3002. #
  3003. have iptables &&
  3004. _iptables()
  3005. {
  3006.     local cur prev table chain
  3007.  
  3008.     COMPREPLY=()
  3009.     cur=`_get_cword`
  3010.     prev=${COMP_WORDS[COMP_CWORD-1]}
  3011.     chain='s/^Chain \([^ ]\+\).*$/\1/p'
  3012.  
  3013.     if [[ $COMP_LINE == *-t\ *filter* ]]; then
  3014.         table="-t filter"
  3015.     elif [[ $COMP_LINE == *-t\ *nat* ]]; then
  3016.         table="-t nat"
  3017.     elif [[ $COMP_LINE == *-t\ *mangle* ]]; then
  3018.         table="-t mangle"
  3019.     fi
  3020.  
  3021.     case "$prev" in
  3022.     -*[AIDRPFXLZ])
  3023.         COMPREPLY=( $( compgen -W '`iptables $table -nL | \
  3024.                 sed -ne "s/^Chain \([^ ]\+\).*$/\1/p"`' -- $cur ) )
  3025.         ;;
  3026.     -*t)
  3027.         COMPREPLY=( $( compgen -W 'nat filter mangle' -- $cur ) )
  3028.         ;;
  3029.     -j)
  3030.         if [ "$table" = "-t filter" -o "$table" = "" ]; then
  3031.             COMPREPLY=( $( compgen -W 'ACCEPT DROP LOG ULOG REJECT \
  3032.             `iptables $table -nL | sed -ne "$chain" \
  3033.             -e "s/INPUT|OUTPUT|FORWARD|PREROUTING|POSTROUTING//"`' -- \
  3034.             $cur ) )
  3035.         elif [ "$table" = "-t nat" ]; then
  3036.             COMPREPLY=( $( compgen -W 'ACCEPT DROP LOG ULOG REJECT \
  3037.             MIRROR SNAT DNAT MASQUERADE `iptables $table -nL | \
  3038.             sed -ne "$chain" -e "s/OUTPUT|PREROUTING|POSTROUTING//"`' \
  3039.             -- $cur ) )
  3040.         elif [ "$table" = "-t mangle" ]; then
  3041.             COMPREPLY=( $( compgen -W 'ACCEPT DROP LOG ULOG REJECT \
  3042.             MARK TOS `iptables $table -nL | sed -ne "$chain" \
  3043.             -e "s/INPUT|OUTPUT|FORWARD|PREROUTING|POSTROUTING//"`' -- \
  3044.             $cur ) )
  3045.         fi
  3046.         ;;
  3047.     *)
  3048.         if [[ "$cur" == -* ]]; then
  3049.             COMPREPLY=( $( compgen -W '-i -o -s -d -p -f -m --append \
  3050.             --delete --insert --replace --list --flush --zero --new \
  3051.             --delete-chain --policy --rename-chain --proto --source \
  3052.             --destination --in-interface --jump --match --numeric \
  3053.             --out-interface --table --verbose --line-numbers --exact \
  3054.             --fragment --modprobe= --set-counters --version' -- "$cur") )
  3055.         fi
  3056.         ;;
  3057.     esac
  3058.  
  3059. } &&
  3060. complete -F _iptables iptables
  3061.  
  3062. # tcpdump(8) completion
  3063. #
  3064. have tcpdump &&
  3065. _tcpdump()
  3066. {
  3067.     local cur
  3068.  
  3069.     COMPREPLY=()
  3070.     cur=`_get_cword`
  3071.     prev=${COMP_WORDS[COMP_CWORD-1]}
  3072.  
  3073.     case "$prev" in
  3074.         -@(r|w|F))
  3075.             _filedir
  3076.             return 0
  3077.             ;;
  3078.         -i)
  3079.             _available_interfaces -a
  3080.             return 0
  3081.             ;;
  3082.     esac
  3083.  
  3084.  
  3085.     if [[ "$cur" == -* ]]; then
  3086.         COMPREPLY=( $( compgen -W '-a -d -e -f -l -n -N -O -p \
  3087.             -q -R -S -t -u -v -x -C -F -i -m -r -s -T -w \
  3088.             -E' -- $cur ) )
  3089.     fi
  3090.  
  3091. } &&
  3092. complete -F _tcpdump tcpdump
  3093.  
  3094. # autorpm(8) completion
  3095. #
  3096. have autorpm &&
  3097. _autorpm()
  3098. {
  3099.     local cur
  3100.  
  3101.     COMPREPLY=()
  3102.     cur=`_get_cword`
  3103.  
  3104.     COMPREPLY=( $( compgen -W '--notty --debug --help --version \
  3105.                    auto add fullinfo info help install list \
  3106.                    remove set' -- $cur ) )
  3107.  
  3108. } &&
  3109. complete -F _autorpm autorpm
  3110.  
  3111. # This meta-cd function observes the CDPATH variable, so that cd additionally
  3112. # completes on directories under those specified in CDPATH.
  3113. #
  3114. _cd()
  3115. {
  3116.     local IFS=$'\t\n' cur=`_get_cword` i j k
  3117.  
  3118.     # try to allow variable completion
  3119.     if [[ "$cur" == ?(\\)\$* ]]; then
  3120.         COMPREPLY=( $( compgen -v -P '$' -- "${cur#?(\\)$}" ) )
  3121.         return 0
  3122.     fi
  3123.  
  3124.     # Use standard dir completion if no CDPATH or parameter starts with /,
  3125.     # ./ or ../
  3126.     if [ -z "${CDPATH:-}" ] || [[ "$cur" == ?(.)?(.)/* ]]; then
  3127.         _filedir -d
  3128.         return 0
  3129.     fi
  3130.  
  3131.     local -r mark_dirs=$(_rl_enabled mark-directories && echo y)
  3132.     local -r mark_symdirs=$(_rl_enabled mark-symlinked-directories && echo y)
  3133.  
  3134.     # we have a CDPATH, so loop on its contents
  3135.     for i in ${CDPATH//:/$'\t'}; do
  3136.         # create an array of matched subdirs
  3137.         k="${#COMPREPLY[@]}"
  3138.         for j in $( compgen -d $i/$cur ); do
  3139.             if [[ ( $mark_symdirs && -h $j || $mark_dirs && ! -h $j ) && ! -d ${j#$i/} ]]; then
  3140.                 j="${j}/"
  3141.             fi
  3142.             COMPREPLY[k++]=${j#$i/}
  3143.         done
  3144.     done
  3145.  
  3146.     _filedir -d
  3147.  
  3148.     if [[ ${#COMPREPLY[@]} -eq 1 ]]; then
  3149.         i=${COMPREPLY[0]}
  3150.         if [ "$i" == "$cur" ] && [[ $i != "*/" ]]; then
  3151.         COMPREPLY[0]="${i}/"
  3152.         fi
  3153.     fi
  3154.         
  3155.     return 0
  3156. }
  3157. if shopt -q cdable_vars; then
  3158.     complete -v -F _cd $nospace $filenames cd
  3159. else
  3160.     complete -F _cd $nospace $filenames cd
  3161. fi
  3162.  
  3163. _remove_comp_word()
  3164. {
  3165.     if [[ COMP_CWORD -eq 0 ]]; then
  3166.         return
  3167.     elif [[ ${#COMP_WORDS[@]} -ge 2 ]]; then
  3168.         local old_cw0="${COMP_WORDS[0]}"
  3169.         local new_cw0="${COMP_WORDS[1]}"
  3170.         local old_length="${#COMP_LINE}"
  3171.         COMP_LINE=${COMP_LINE#${old_cw0}}
  3172.         local head=${COMP_LINE:0:${#new_cw0}}
  3173.         local i=1
  3174.         while [[ $head != $new_cw0 ]]; do
  3175.             COMP_LINE=${COMP_LINE:1}
  3176.             head=${COMP_LINE:0:${#new_cw0}}
  3177.             if (( ++i > 10 )); then
  3178.                 break
  3179.             fi
  3180.         done
  3181.         local new_length="${#COMP_LINE}"
  3182.         COMP_POINT=$(( COMP_POINT + new_length - old_length))
  3183.  
  3184.         COMP_CWORD=$(( COMP_CWORD - 1 ))
  3185.         for (( i=0; i < ${#COMP_WORDS[@]} - 1; ++i )); do
  3186.             COMP_WORDS[i]="${COMP_WORDS[i+1]}"
  3187.         done
  3188.         unset COMP_WORDS[${#COMP_WORDS[@]}-1]
  3189.     else
  3190.         return
  3191.     fi
  3192. }
  3193.  
  3194. # A meta-command completion function for commands like sudo(8), which need to
  3195. # first complete on a command, then complete according to that command's own
  3196. # completion definition - currently not quite foolproof (e.g. mount and umount
  3197. # don't work properly), but still quite useful.
  3198. #
  3199. _command()
  3200. {
  3201.     local cur func cline cspec noglob cmd done i \
  3202.           _COMMAND_FUNC _COMMAND_FUNC_ARGS
  3203.  
  3204.     _remove_comp_word
  3205.     COMPREPLY=()
  3206.     cur=`_get_cword`
  3207.     # If the the first arguments following our meta-command-invoker are
  3208.     # switches, get rid of them. Most definitely not foolproof.
  3209.     done=
  3210.     while [ -z $done ] ; do
  3211.         cmd=${COMP_WORDS[0]}
  3212.         if [[ "$cmd" == -* ]] && [ $COMP_CWORD -ge 1 ]; then
  3213.             _remove_comp_word
  3214.         elif [[ "$cmd" == -* ]] && [[ $COMP_CWORD -eq 0 ]]; then
  3215.         return
  3216.         else 
  3217.         done=1
  3218.         fi
  3219.     done
  3220.  
  3221.     if [ $COMP_CWORD -eq 0 ]; then
  3222.         COMPREPLY=( $( compgen -c -- $cur ) )
  3223.     elif complete -p $cmd &>/dev/null; then
  3224.         cspec=$( complete -p $cmd )
  3225.         if [ "${cspec#* -F }" != "$cspec" ]; then
  3226.             # COMP_CWORD and COMP_WORDS() are not read-only,
  3227.             # so we can set them before handing off to regular
  3228.             # completion routine
  3229.  
  3230.             # get function name
  3231.             func=${cspec#*-F }
  3232.             func=${func%% *}
  3233.  
  3234.             if [[ ${#COMP_WORDS[@]} -ge 2 ]]; then
  3235.                 $func $cmd "${COMP_WORDS[${#COMP_WORDS[@]}-1]}" "${COMP_WORDS[${#COMP_WORDS[@]}-2]}"
  3236.             else
  3237.                 $func $cmd "${COMP_WORDS[${#COMP_WORDS[@]}-1]}"
  3238.             fi
  3239.  
  3240.             # remove any \: generated by a command that doesn't
  3241.             # default to filenames or dirnames (e.g. sudo chown)
  3242.             # FIXME: I'm pretty sure this does not work!
  3243.             if [ "${cspec#*-o }" != "$cspec" ]; then
  3244.                 cspec=${cspec#*-o }
  3245.                 cspec=${cspec%% *}
  3246.                 if [[ "$cspec" != @(dir|file)names ]]; then
  3247.                     COMPREPLY=("${COMPREPLY[@]//\\\\:/:}")
  3248.                 fi
  3249.             fi
  3250.         elif [ -n "$cspec" ]; then
  3251.             cspec=${cspec#complete};
  3252.             cspec=${cspec%%$cmd};
  3253.             COMPREPLY=( $( eval compgen "$cspec" -- "$cur" ) );
  3254.         fi
  3255.     fi
  3256.  
  3257.     [ ${#COMPREPLY[@]} -eq 0 ] && _filedir
  3258. }
  3259. complete -F _command $filenames nohup exec nice eval strace time ltrace then \
  3260.     else do vsound command xargs
  3261.  
  3262. _root_command()
  3263. {
  3264.     PATH=$PATH:/sbin:/usr/sbin:/usr/local/sbin _command $1 $2 $3
  3265. }
  3266. complete -F _root_command $filenames sudo fakeroot really
  3267.  
  3268. # ant(1) completion
  3269. #
  3270. have ant && {
  3271. _ant()
  3272. {
  3273.     local cur prev buildfile i
  3274.  
  3275.     COMPREPLY=()
  3276.     cur=`_get_cword`
  3277.     prev=${COMP_WORDS[COMP_CWORD-1]}
  3278.  
  3279.     case "$prev" in
  3280.         -buildfile|-f)
  3281.             _filedir 'xml'
  3282.             return 0
  3283.             ;;
  3284.         -logfile)
  3285.             _filedir
  3286.             return 0
  3287.             ;;
  3288.     esac
  3289.  
  3290.     if [[ "$cur" == -* ]]; then
  3291.         # relevant options completion
  3292.         COMPREPLY=( $( compgen -W '-help -projecthelp -version -quiet \
  3293.                    -verbose -debug -emacs -logfile -logger \
  3294.                    -listener -buildfile -f -D -find' -- $cur ) )
  3295.     else
  3296.         # available targets completion
  3297.         # find which buildfile to use
  3298.         buildfile=build.xml
  3299.         for (( i=1; i < COMP_CWORD; i++ )); do
  3300.             if [[ "${COMP_WORDS[i]}" == -buildfile ]]; then
  3301.                 buildfile=${COMP_WORDS[i+1]}
  3302.                 break
  3303.             fi
  3304.         done
  3305.         [ ! -f $buildfile ] && return 0
  3306.  
  3307.         # parse buildfile for targets
  3308.         COMPREPLY=( $( awk -F'"' '/<target name="/ {print $2}' \
  3309.                 $buildfile | grep "^$cur" )
  3310.                 $( awk -F"'" "/<target name='/ "'{print $2}' \
  3311.                 $buildfile | grep "^$cur" )
  3312.                 $( awk -F'"' '/<target [^n]/ {if ($1 ~ /name=/) { print $2 } else if ($3 ~ /name=/) {print $4} else if ($5 ~ /name=/) {print $6}}' \
  3313.                 $buildfile | grep "^$cur" ) )
  3314.     fi
  3315. }
  3316. have complete-ant-cmd.pl && \
  3317.      complete -C complete-ant-cmd.pl -F _ant $filenames ant || \
  3318.      complete -F _ant $filenames ant
  3319. }
  3320.  
  3321. have nslookup &&
  3322. _nslookup()
  3323. {
  3324.     local cur
  3325.  
  3326.     COMPREPLY=()
  3327.     cur=${COMP_WORDS[COMP_CWORD]#-}
  3328.  
  3329.     COMPREPLY=( $( compgen -P '-' -W 'all class= debug d2 domain= \
  3330.                    srchlist= defname search port= querytype= \
  3331.                    type= recurse retry root timeout vc \
  3332.                    ignoretc' -- $cur ) )
  3333. } &&
  3334. complete -F _nslookup nslookup
  3335.  
  3336. # mysqladmin(1) completion
  3337. #
  3338. have mysqladmin &&
  3339. _mysqladmin()
  3340. {
  3341.     local cur prev
  3342.  
  3343.     COMPREPLY=()
  3344.     cur=`_get_cword`
  3345.     prev=${COMP_WORDS[COMP_CWORD-1]}
  3346.  
  3347.     case "$prev" in
  3348.     -u)
  3349.         COMPREPLY=( $( compgen -u -- $cur ) )
  3350.         return 0
  3351.         ;;
  3352.     *)
  3353.         ;;
  3354.     esac
  3355.  
  3356.     COMPREPLY=( $( compgen -W '-# -f -? -C -h -p -P -i -r -E -s -S -t -u \
  3357.                           -v -V -w' -- $cur ) )
  3358.  
  3359.     COMPREPLY=( "${COMPREPLY[@]}" \
  3360.             $( compgen -W 'create drop extended-status flush-hosts \
  3361.                    flush-logs flush-status flush-tables \
  3362.                    flush-threads flush-privileges kill \
  3363.                    password ping processlist reload refresh \
  3364.                    shutdown status variables version' \
  3365.                -- $cur ) )
  3366. } &&
  3367. complete -F _mysqladmin mysqladmin
  3368.  
  3369. # gzip(1) completion
  3370. #
  3371. have gzip &&
  3372. _gzip()
  3373. {
  3374.     local cur prev xspec IFS=$'\t\n'
  3375.  
  3376.     COMPREPLY=()
  3377.     cur=`_get_cword`
  3378.     prev=${COMP_WORDS[COMP_CWORD-1]}
  3379.  
  3380.     if [[ "$cur" == -* ]]; then
  3381.         COMPREPLY=( $( compgen -W '-c -d -f \
  3382.             -h -l -L -n -N -q -r -S -t -v -V \
  3383.             -1 -2 -3 -4 -5 -6 -7 -8 -9 \
  3384.             --stdout --decompress --force --help --list \
  3385.             --license --no-name --name --quiet --recursive \
  3386.             --suffix --test --verbose --version --fast \
  3387.             --best' -- $cur ) )
  3388.         return 0
  3389.     fi
  3390.  
  3391.     xspec="*.?(t)gz"
  3392.     if [[ "$prev" == --* ]]; then
  3393.         [[ "$prev" == --decompress || \
  3394.             "$prev" == --list || \
  3395.             "$prev" == --test ]] && xspec="!"$xspec
  3396.         [[ "$prev" == --force ]] && xspec=
  3397.     elif [[ "$prev" == -* ]]; then
  3398.         [[ "$prev" == -*[dlt]* ]] && xspec="!"$xspec
  3399.         [[ "$prev" == -*f* ]] && xspec=
  3400.     elif [ "$prev" = '>' ]; then
  3401.         xspec=
  3402.     elif [ "$prev" = '<' ]; then
  3403.         xspec=
  3404.     fi
  3405.  
  3406.     _expand || return 0
  3407.  
  3408.     COMPREPLY=( $( compgen -f -X "$xspec" -- $cur ) \
  3409.             $( compgen -d -- $cur ) )
  3410. } &&
  3411. complete -F _gzip $filenames gzip
  3412.  
  3413. # bzip2(1) completion
  3414. #
  3415. have bzip2 &&
  3416. _bzip2()
  3417. {
  3418.     local cur prev xspec IFS=$'\t\n'
  3419.  
  3420.     COMPREPLY=()
  3421.     cur=`_get_cword`
  3422.     prev=${COMP_WORDS[COMP_CWORD-1]}
  3423.  
  3424.     if [[ "$cur" == -* ]]; then
  3425.         COMPREPLY=( $( compgen -W '-c -d -f -h -k -L -q -s \
  3426.             -t -v -V -z -1 -2 -3 -4 -5 -6 -7 -8 -9 \
  3427.             --help --decompress --compress --keep --force \
  3428.             --test --stdout --quiet --verbose --license \
  3429.             --version --small --fast --best' -- $cur ) )
  3430.         return 0
  3431.     fi
  3432.  
  3433.     xspec="*.bz2"
  3434.     if [[ "$prev" == --* ]]; then
  3435.         [[ "$prev" == --decompress || \
  3436.             "$prev" == --list || \
  3437.             "$prev" == --test ]] && xspec="!"$xspec
  3438.         [[ "$prev" == --compress ]] && xspec=
  3439.     elif [[ "$prev" == -* ]]; then
  3440.         [[ "$prev" == -*[dt]* ]] && xspec="!"$xspec
  3441.         [[ "$prev" == -*z* ]] && xspec=
  3442.     fi
  3443.  
  3444.     _expand || return 0
  3445.  
  3446.     COMPREPLY=( $( compgen -f -X "$xspec" -- $cur ) \
  3447.             $( compgen -d -- $cur ) )
  3448. } &&
  3449. complete -F _bzip2 $filenames bzip2
  3450.  
  3451. # openssl(1) completion
  3452. #
  3453. have openssl && {
  3454. _openssl_sections()
  3455. {
  3456.     local config
  3457.  
  3458.     config=/etc/ssl/openssl.cnf
  3459.     [ ! -f $config ] && config=/usr/share/ssl/openssl.cnf
  3460.     for (( i=2; i < COMP_CWORD; i++ )); do
  3461.         if [[ "${COMP_WORDS[i]}" == -config ]]; then
  3462.             config=${COMP_WORDS[i+1]}
  3463.             break
  3464.         fi
  3465.     done
  3466.     [ ! -f $config ] && return 0
  3467.  
  3468.     COMPREPLY=( $( awk '/\[.*\]/ {print $2} ' $config | grep "^$cur" ) )
  3469. }
  3470.  
  3471. _openssl()
  3472. {
  3473.     local cur prev
  3474.  
  3475.     COMPREPLY=()
  3476.     cur=`_get_cword`
  3477.  
  3478.     if [ $COMP_CWORD -eq 1 ]; then
  3479.         COMPREPLY=( $( compgen -W 'asn1parse ca ciphers crl crl2pkcs7 \
  3480.             dgst dh dhparam dsa dsaparam enc errstr gendh gendsa \
  3481.             genrsa nseq passwd pkcs12 pkcs7 pkcs8 rand req rsa \
  3482.             rsautl s_client s_server s_time sess_id smime speed \
  3483.             spkac verify version x509 md2 md4 md5 mdc2 rmd160 sha \
  3484.             sha1 base64 bf bf-cbc bf-cfb bf-ecb bf-ofb cast \
  3485.             cast-cbc cast5-cbc cast5-cfb cast5-ecb cast5-ofb des \
  3486.             des-cbc des-cfb des-ecb des-ede des-ede-cbc \
  3487.             des-ede-cfb des-ede-ofb des-ede3 des-ede3-cbc \
  3488.             des-ede3-cfb des-ede3-ofb des-ofb des3 desx rc2 \
  3489.             rc2-40-cbc rc2-64-cbc rc2-cbc rc2-cfb rc2-ecb rc2-ofb \
  3490.             rc4 rc4-40' -- $cur ) )
  3491.     else
  3492.         prev=${COMP_WORDS[COMP_CWORD-1]}
  3493.         case ${COMP_WORDS[1]} in
  3494.             asn1parse)
  3495.                 case $prev in
  3496.                     -inform)
  3497.                         COMPREPLY=( $( compgen -W 'DER PEM' -- $cur ) )
  3498.                         return 0
  3499.                         ;;
  3500.                     -@(in|out|oid))
  3501.                         _filedir
  3502.                         return 0
  3503.                         ;;
  3504.                     esac
  3505.  
  3506.                 if [[ "$cur" == -* ]]; then
  3507.                     COMPREPLY=( $( compgen -W '-inform -in -out -noout -offset \
  3508.                         -length -i -oid -strparse' -- $cur ) )
  3509.                 fi
  3510.                 ;;
  3511.             ca)
  3512.                 case $prev in
  3513.                     -@(config|revoke|cert|in|out|spkac|ss_cert))
  3514.                         _filedir
  3515.                         return 0
  3516.                         ;;
  3517.                     -outdir)
  3518.                         _filedir -d
  3519.                         return 0
  3520.                         ;;
  3521.                     -@(name|crlexts|extensions))
  3522.                         _openssl_sections
  3523.                         return 0
  3524.                         ;;
  3525.                 esac
  3526.  
  3527.                 if [[ "$cur" == -* ]]; then
  3528.                     COMPREPLY=( $( compgen -W '-verbose -config -name \
  3529.                         -gencrl -revoke -crldays -crlhours -crlexts \
  3530.                         -startdate -enddate -days -md -policy -keyfile \
  3531.                         -key -passin -cert -in -out -notext -outdir \
  3532.                         -infiles -spkac -ss_cert -preserveDN -batch \
  3533.                         -msie_hack -extensions' -- $cur ) )
  3534.                 fi
  3535.                 ;;
  3536.             ciphers)
  3537.                 if [[ "$cur" == -* ]]; then
  3538.                     COMPREPLY=( $( compgen -W '-v -ssl2 -ssl3 -tls1' -- $cur ) )
  3539.                 fi
  3540.                 ;;
  3541.             crl)
  3542.                 case $prev in
  3543.                     -@(in|out)form)
  3544.                         COMPREPLY=( $( compgen -W 'DER PEM' -- $cur ) )
  3545.                         return 0
  3546.                         ;;
  3547.                     -@(in|out|CAfile))
  3548.                         _filedir
  3549.                         return 0
  3550.                         ;;
  3551.                     -CAPath)
  3552.                         _filedir -d
  3553.                         return 0
  3554.                         ;;
  3555.                 esac
  3556.  
  3557.                 if [[ "$cur" == -* ]]; then
  3558.                     COMPREPLY=( $( compgen -W '-inform -outform -text -in -out -noout \
  3559.                         -hash -issuer -lastupdate -nextupdate -CAfile -CApath' -- $cur ) )
  3560.                 fi
  3561.                 ;;
  3562.             crl2pkcs7)
  3563.                 case $prev in
  3564.                     -@(in|out)form)
  3565.                         COMPREPLY=( $( compgen -W 'DER PEM' -- $cur ) )
  3566.                         return 0
  3567.                         ;;
  3568.                     -@(in|out))
  3569.                         _filedir
  3570.                         return 0
  3571.                         ;;
  3572.                 esac
  3573.  
  3574.                 if [[ "$cur" == -* ]]; then
  3575.                     COMPREPLY=( $( compgen -W '-inform -outform -in -out -print_certs' -- $cur ) )
  3576.                 fi
  3577.                 ;;
  3578.             dgst)
  3579.                 case $prev in
  3580.                     -@(out|sign|verify|prvrify|signature))
  3581.                         _filedir
  3582.                         return 0
  3583.                         ;;
  3584.                 esac
  3585.  
  3586.                 if [[ "$cur" == -* ]]; then
  3587.                     COMPREPLY=( $( compgen -W '-md5 -md4 -md2 -sha1 -sha -mdc2 -ripemd160 -dss1 \
  3588.                         -c -d -hex -binary -out -sign -verify -prverify -signature' -- $cur ) )
  3589.                 else
  3590.                         _filedir
  3591.                 fi
  3592.                    ;;
  3593.             dsa)
  3594.                 case $prev in
  3595.                     -@(in|out)form)
  3596.                         COMPREPLY=( $( compgen -W 'DER PEM' -- $cur ) )
  3597.                         return 0
  3598.                         ;;
  3599.                     -@(in|out))
  3600.                         _filedir
  3601.                         return 0
  3602.                         ;;
  3603.                 esac
  3604.  
  3605.                 if [[ "$cur" == -* ]]; then
  3606.                     COMPREPLY=( $( compgen -W '-inform -outform -in -passin -out -passout -des -des3 -idea -text -noout \
  3607.                         -modulus -pubin -pubout' -- $cur ) )
  3608.                 fi
  3609.                 ;;
  3610.             dsaparam)
  3611.                 case $prev in
  3612.                     -@(in|out)form)
  3613.                         COMPREPLY=( $( compgen -W 'DER PEM' -- $cur ) )
  3614.                         return 0
  3615.                         ;;
  3616.                     -@(in|out|rand))
  3617.                         _filedir
  3618.                         return 0
  3619.                         ;;
  3620.                 esac
  3621.  
  3622.                 if [[ "$cur" == -* ]]; then
  3623.                     COMPREPLY=( $( compgen -W '-inform -outform -in -out -noout \
  3624.                         -text -C -rand -genkey' -- $cur ) )
  3625.                 fi
  3626.                 ;;
  3627.             enc)
  3628.                 case $prev in
  3629.                     -@(in|out|kfile))
  3630.                         _filedir
  3631.                         return 0
  3632.                         ;;
  3633.                 esac
  3634.  
  3635.                 if [[ "$cur" == -* ]]; then
  3636.                     COMPREPLY=( $( compgen -W '-ciphername -in -out -pass \
  3637.                         -e -d -a -A -k -kfile -S -K -iv -p -P -bufsize -debug' -- $cur ) )
  3638.                 fi
  3639.                 ;;
  3640.             dhparam)
  3641.                 case $prev in
  3642.                     -@(in|out)form)
  3643.                         COMPREPLY=( $( compgen -W 'DER PEM' -- $cur ) )
  3644.                         return 0
  3645.                         ;;
  3646.                     -@(in|out|rand))
  3647.                         _filedir
  3648.                         return 0
  3649.                         ;;
  3650.                 esac
  3651.  
  3652.                 if [[ "$cur" == -* ]]; then
  3653.                     COMPREPLY=( $( compgen -W '-inform -outform -in -out -dsaparam -noout \
  3654.                         -text -C -2 -5 -rand' -- $cur ) )
  3655.                 fi
  3656.                 ;;
  3657.             gendsa)
  3658.                 case $prev in
  3659.                     -@(out|rand))
  3660.                         _filedir
  3661.                         return 0
  3662.                         ;;
  3663.                 esac
  3664.  
  3665.                 if [[ "$cur" == -* ]]; then
  3666.                     COMPREPLY=( $( compgen -W '-out -des -des3 -idea -rand' -- $cur ) )
  3667.                 else
  3668.                         _filedir
  3669.                 fi
  3670.                 ;;
  3671.             genrsa)
  3672.                 case $prev in
  3673.                     -@(out|rand))
  3674.                         _filedir
  3675.                         return 0
  3676.                         ;;
  3677.                 esac
  3678.  
  3679.                 if [[ "$cur" == -* ]]; then
  3680.                     COMPREPLY=( $( compgen -W '-out -passout -des -des3 -idea -f4 -3 -rand' -- $cur ) )
  3681.                 fi
  3682.                 ;;
  3683.             pkcs7)
  3684.                 case $prev in
  3685.                     -@(in|out)form)
  3686.                         COMPREPLY=( $( compgen -W 'DER PEM' -- $cur ) )
  3687.                         return 0
  3688.                         ;;
  3689.                     -@(in|out))
  3690.                         _filedir
  3691.                         return 0
  3692.                         ;;
  3693.                 esac
  3694.  
  3695.                 if [[ "$cur" == -* ]]; then
  3696.                     COMPREPLY=( $( compgen -W '-inform -outform -in -out -print_certs -text -noout' -- $cur ) )
  3697.                 fi
  3698.                 ;;
  3699.             rand)
  3700.                 case $prev in
  3701.                     -@(out|rand))
  3702.                         _filedir
  3703.                         return 0
  3704.                         ;;
  3705.                 esac
  3706.  
  3707.                 if [[ "$cur" == -* ]]; then
  3708.                     COMPREPLY=( $( compgen -W '-out -rand -base64' -- $cur ) )
  3709.                 fi
  3710.                 ;;
  3711.             req)
  3712.                 case "$prev" in
  3713.                     -@(in|out|key)form)
  3714.                         COMPREPLY=( $( compgen -W 'DER PEM' -- $cur ) )
  3715.                         return 0
  3716.                         ;;
  3717.  
  3718.                     -@(in|out|rand|key|keyout|config))
  3719.                         _filedir
  3720.                         return 0
  3721.                         ;;
  3722.                     -extensions)
  3723.                         _openssl_sections
  3724.                         return 0
  3725.                         ;;
  3726.                 esac
  3727.  
  3728.                 if [[ "$cur" == -* ]]; then
  3729.                     COMPREPLY=( $( compgen -W '-inform -outform -in \
  3730.                         -passin -out -passout -text -noout -verify \
  3731.                         -modulus -new -rand -newkey -newkey -nodes \
  3732.                         -key -keyform -keyout -md5 -sha1 -md2 -mdc2 \
  3733.                         -config -x509 -days -asn1-kludge -newhdr \
  3734.                         -extensions -reqexts section' -- $cur ) )
  3735.                 fi
  3736.                 ;;
  3737.             rsa)
  3738.                 case $prev in
  3739.                     -@(in|out)form)
  3740.                         COMPREPLY=( $( compgen -W 'DER NET PEM' -- $cur ) )
  3741.                         return 0
  3742.                         ;;
  3743.                     -@(in|out))
  3744.                         _filedir
  3745.                         return 0
  3746.                         ;;
  3747.                 esac
  3748.  
  3749.                 if [[ "$cur" == -* ]]; then
  3750.                     COMPREPLY=( $( compgen -W '-inform -outform -in -passin -out -passout \
  3751.                         -sgckey -des -des3 -idea -text -noout -modulus -check -pubin \
  3752.                         -pubout -engine' -- $cur ) )
  3753.                 fi
  3754.                 ;;
  3755.             rsautl)
  3756.                 case $prev in
  3757.                     -@(in|out|inkey))
  3758.                         _filedir
  3759.                         return 0
  3760.                         ;;
  3761.                 esac
  3762.  
  3763.                 if [[ "$cur" == -* ]]; then
  3764.                     COMPREPLY=( $( compgen -W '-in -out -inkey -pubin -certin -sign -verify \
  3765.                         -encrypt -decrypt -pkcs -ssl -raw -hexdump -asn1parse' -- $cur ) )
  3766.                 fi
  3767.                 ;;
  3768.             s_client)
  3769.                 case $prev in
  3770.                     -connect)
  3771.                         _known_hosts
  3772.                         return 0
  3773.                         ;;
  3774.                     -@(cert|key|CAfile|rand))
  3775.                         _filedir
  3776.                         return 0
  3777.                         ;;
  3778.                     -CApath)
  3779.                         _filedir -d
  3780.                         return 0
  3781.                         ;;
  3782.                 esac
  3783.  
  3784.                 if [[ "$cur" == -* ]]; then
  3785.                     COMPREPLY=( $( compgen -W '-connect -verify -cert -key -CApath -CAfile \
  3786.                         -reconnect -pause -showcerts -debug -msg -nbio_test -state -nbio \
  3787.                         -crlf -ign_eof -quiet -ssl2 -ssl3 -tls1 -no_ssl2 -no_ssl3 -no_tls1 \
  3788.                         -bugs -cipher -starttls -engine -rand' -- $cur ) )
  3789.                 fi
  3790.                 ;;
  3791.             s_server)
  3792.                 case $prev in
  3793.                     -@(cert|key|dcert|dkey|dhparam|CAfile|rand))
  3794.                         _filedir
  3795.                         return 0
  3796.                         ;;
  3797.                     -CApath)
  3798.                         _filedir -d
  3799.                         return 0
  3800.                         ;;
  3801.                 esac
  3802.  
  3803.                 if [[ "$cur" == -* ]]; then
  3804.                     COMPREPLY=( $( compgen -W '-accept -context -verify -Verify -cert -key \
  3805.                          -dcert -dkey -dhparam -nbio -nbio_test -crlf -debug -msg -state -CApath \
  3806.                          -CAfile -nocert -cipher -quiet -no_tmp_rsa -ssl2 -ssl3 -tls1 -no_ssl2 \
  3807.                          -no_ssl3 -no_tls1 -no_dhe -bugs -hack -www -WWW -HTTP -engine -id_prefix \
  3808.                          -rand' -- $cur ) )
  3809.                  fi
  3810.                  ;;
  3811.             s_time)
  3812.                 case $prev in
  3813.                     -connect)
  3814.                         _known_hosts
  3815.                         return 0
  3816.                         ;;
  3817.                     -@(cert|key|CAfile))
  3818.                         _filedir
  3819.                         return 0
  3820.                         ;;
  3821.                     -CApath)
  3822.                         _filedir -d
  3823.                         return 0
  3824.                         ;;
  3825.                 esac
  3826.  
  3827.                 if [[ "$cur" == -* ]]; then
  3828.                     COMPREPLY=( $( compgen -W '-connect -www -cert -key -CApath -CAfile -reuse \
  3829.                         -new -verify -nbio -time -ssl2 -ssl3 -bugs -cipher' -- $cur ) )
  3830.                 fi
  3831.                 ;;
  3832.  
  3833.             sess_id) 
  3834.                 case $prev in
  3835.                     -@(in|out)form)
  3836.                         COMPREPLY=( $( compgen -W 'DER PEM' -- $cur ) )
  3837.                         return 0
  3838.                         ;;
  3839.                     -@(in|out))
  3840.                         _filedir
  3841.                         return 0
  3842.                         ;;
  3843.                 esac
  3844.  
  3845.  
  3846.                 if [[ "$cur" == -* ]]; then
  3847.                     COMPREPLY=( $( compgen -W '-inform -outform -in -out -text -noout \
  3848.                         -context ID' -- $cur ) )
  3849.                 fi
  3850.                 ;;
  3851.             smime)
  3852.                 case $prev in
  3853.                     -@(in|out)form)
  3854.                         COMPREPLY=( $( compgen -W 'SMIME DER PEM' -- $cur ) )
  3855.                         return 0
  3856.                         ;;
  3857.                     -@(in|out|certfile|signer|recip|inkey|content|rand))
  3858.                         _filedir
  3859.                         return 0
  3860.                         ;;
  3861.                 esac
  3862.  
  3863.                 if [[ "$cur" == -* ]]; then
  3864.                     COMPREPLY=( $( compgen -W '-encrypt -decrypt -sign -verify -pk7out -des -des3 \
  3865.                         -rc2-40 -rc2-64 -rc2-128 -aes128 -aes192 -aes256 -in -certfile -signer \
  3866.                         -recip -inform -passin -inkey -out -outform -content -to -from -subject \
  3867.                         -text -rand' -- $cur ) )
  3868.                 else
  3869.                         _filedir
  3870.                 fi
  3871.                 ;;
  3872.             speed)
  3873.                 if [[ "$cur" == -* ]]; then
  3874.                     COMPREPLY=( $( compgen -W '-engine' -- $cur ) )
  3875.                 else
  3876.                     COMPREPLY=( $( compgen -W 'md2 mdc2 md5 hmac sha1 rmd160 idea-cbc \
  3877.                         rc2-cbc rc5-cbc bf-cbc des-cbc des-ede3 rc4 rsa512 rsa1024 rsa2048 \
  3878.                         rsa4096 dsa512 dsa1024 dsa2048 idea rc2 des rsa blowfish' -- $cur ) )
  3879.                 fi
  3880.                 ;;
  3881.             verify)
  3882.                 case $prev in
  3883.                     -@(CAfile|untrusted))
  3884.                         _filedir
  3885.                         return 0
  3886.                         ;;
  3887.                     -CApath)
  3888.                         _filedir -d
  3889.                         return 0
  3890.                         ;;
  3891.                 esac
  3892.  
  3893.                 if [[ "$cur" == -* ]]; then
  3894.                     COMPREPLY=( $( compgen -W '-CApath -CAfile -purpose -untrusted -help -issuer_checks \
  3895.                         -verbose -certificates' -- $cur ) )
  3896.                 else
  3897.                         _filedir
  3898.                 fi
  3899.                 ;;
  3900.             x509)
  3901.                 case "$prev" in
  3902.                     -@(in|out|CA|CAkey|CAserial|extfile))
  3903.                         _filedir
  3904.                         return 0
  3905.                         ;;
  3906.                     -@(in|out)form)
  3907.                         COMPREPLY=( $( compgen -W 'DER PEM NET' -- $cur ) )
  3908.                         return 0
  3909.                         ;;
  3910.                     -@(key|CA|CAkey)form)
  3911.                         COMPREPLY=( $( compgen -W 'DER PEM' -- $cur ) )
  3912.                         return 0
  3913.                         ;;
  3914.                     -extensions)
  3915.                         _openssl_sections
  3916.                         return 0
  3917.                         ;;
  3918.                 esac
  3919.  
  3920.                 if [[ "$cur" == -* ]]; then
  3921.                     COMPREPLY=( $( compgen -W '-inform -outform \
  3922.                         -keyform -CAform -CAkeyform -in -out \
  3923.                         -serial -hash -subject -issuer -nameopt \
  3924.                         -email -startdate -enddate -purpose \
  3925.                         -dates -modulus -fingerprint -alias \
  3926.                         -noout -trustout -clrtrust -clrreject \
  3927.                         -addtrust -addreject -setalias -days \
  3928.                         -set_serial -signkey -x509toreq -req \
  3929.                         -CA -CAkey -CAcreateserial -CAserial \
  3930.                         -text -C -md2 -md5 -sha1 -mdc2 -clrext \
  3931.                         -extfile -extensions -engine' -- $cur ) )
  3932.                 fi
  3933.                 ;;
  3934.             @(md5|md4|md2|sha1|sha|mdc2|ripemd160))
  3935.                 if [[ "$cur" == -* ]]; then
  3936.                     COMPREPLY=( $( compgen -W '-c -d' -- $cur ) )
  3937.                 else
  3938.                         _filedir
  3939.                 fi
  3940.                 ;;
  3941.         esac
  3942.     fi
  3943.  
  3944.     return 0
  3945. }
  3946. complete -F _openssl $default openssl
  3947. }
  3948.  
  3949. # screen(1) completion
  3950. #
  3951. have screen &&
  3952. _screen()
  3953. {
  3954.     local cur prev preprev
  3955.  
  3956.     COMPREPLY=()
  3957.     cur=`_get_cword`
  3958.     prev=${COMP_WORDS[COMP_CWORD-1]}
  3959.  
  3960.     [ "$COMP_CWORD" -ge 2 ] && preprev=${COMP_WORDS[COMP_CWORD-2]}
  3961.  
  3962.     if [ "$preprev" = "-d" -o "$preprev" = "-D" -a "$prev" = "-r" -o \
  3963.          "$prev" = "-R" ]; then
  3964.         # list all
  3965.         COMPREPLY=( $( command screen -ls | \
  3966.                 sed -ne 's|^['$'\t'']\+\('$cur'[0-9]\+\.[^'$'\t'']\+\).*$|\1|p' ) )
  3967.     else
  3968.         case "$prev" in
  3969.         -[rR])
  3970.             # list detached
  3971.             COMPREPLY=( $( command screen -ls | \
  3972.                     sed -ne 's|^['$'\t'']\+\('$cur'[0-9]\+\.[^'$'\t'']\+\).*Detached.*$|\1|p' ) )
  3973.             ;;
  3974.         -[dDx])
  3975.             # list attached
  3976.             COMPREPLY=( $( command screen -ls | \
  3977.                     sed -ne 's|^['$'\t'']\+\('$cur'[0-9]\+\.[^'$'\t'']\+\).*Attached.*$|\1|p' ) )
  3978.             ;;
  3979.         -s)
  3980.             # shells
  3981.             COMPREPLY=( $( grep ^${cur:-[^#]} /etc/shells ) )
  3982.             ;;
  3983.         *)
  3984.             ;;
  3985.         esac
  3986.     fi
  3987.  
  3988.     return 0
  3989. } &&
  3990. complete -F _screen $default screen
  3991.  
  3992. # lftp(1) bookmark completion
  3993. #
  3994. have lftp &&
  3995. _lftp()
  3996. {
  3997.     local cur
  3998.  
  3999.     COMPREPLY=()
  4000.     cur=`_get_cword`
  4001.  
  4002.     if [ $COMP_CWORD -eq 1 ] && [ -f ~/.lftp/bookmarks ]; then
  4003.         COMPREPLY=( $( compgen -W '$( sed -ne "s/^\(.*\)'$'\t''.*$/\1/p" \
  4004.                ~/.lftp/bookmarks )' -- $cur ) )
  4005.     fi
  4006.  
  4007.     return 0
  4008. } &&
  4009. complete -F _lftp $default lftp
  4010.  
  4011. # ncftp(1) bookmark completion
  4012. #
  4013. have ncftp &&
  4014. _ncftp()
  4015. {
  4016.     local cur
  4017.  
  4018.     COMPREPLY=()
  4019.     cur=`_get_cword`
  4020.  
  4021.     if [ $COMP_CWORD -eq 1 ] && [ -f ~/.ncftp/bookmarks ]; then
  4022.         COMPREPLY=( $( compgen -W '$( sed -ne "s/^\([^,]\{1,\}\),.*$/\1/p" \
  4023.                ~/.ncftp/bookmarks )' -- $cur ) )
  4024.     fi
  4025.  
  4026.     return 0
  4027. } &&
  4028. complete -F _ncftp $default ncftp
  4029.  
  4030. # gdb(1) completion
  4031. #
  4032. have gdb &&
  4033. _gdb()
  4034. {
  4035.     local cur prev
  4036.  
  4037.     COMPREPLY=()
  4038.     cur=`_get_cword`
  4039.     prev=${COMP_WORDS[COMP_CWORD-1]}
  4040.  
  4041.     if [ $COMP_CWORD -eq 1 ]; then
  4042.         COMPREPLY=( $( compgen -c -- $cur ) )
  4043.     elif [ $COMP_CWORD -eq 2 ]; then
  4044.         prev=${prev##*/}
  4045.         COMPREPLY=( $( compgen -fW "$( command ps axo comm,pid | \
  4046.                 awk '{if ($1 ~ /^'"$prev"'/) print $2}' ) )" \
  4047.                 -- "$cur" ) )
  4048.     fi
  4049. } &&
  4050. complete -F _gdb $filenames gdb
  4051.  
  4052. # Postgresql completion
  4053. #
  4054. have psql && {
  4055. _pg_databases() 
  4056. {
  4057.     return
  4058.     COMPREPLY=( $( psql -l 2>/dev/null | \
  4059.             sed -e '1,/^-/d' -e '/^(/,$d' | \
  4060.             awk '{print $1}' | grep "^$cur" ) )
  4061. }
  4062.  
  4063. _pg_users()
  4064. {
  4065.     #COMPREPLY=( $( psql -qtc 'select usename from pg_user' template1 2>/dev/null | \
  4066.     #        grep "^ $cur" ) )
  4067.     #[ ${#COMPREPLY[@]} -eq 0 ] &&
  4068.     COMPREPLY=( $( compgen -u -- $cur ) )
  4069. }
  4070.  
  4071. # createdb(1) completion
  4072. #
  4073. _createdb() 
  4074. {
  4075.     local cur prev
  4076.  
  4077.     COMPREPLY=()
  4078.     cur=`_get_cword`
  4079.     prev=${COMP_WORDS[COMP_CWORD-1]}
  4080.  
  4081.     case "$prev" in
  4082.     -@(h|-host=)) 
  4083.         _known_hosts
  4084.         return 0
  4085.         ;;
  4086.     -@(U|-username=))
  4087.         _pg_users
  4088.         return 0
  4089.         ;;
  4090.     esac
  4091.  
  4092.     if [[ "$cur" == -* ]]; then
  4093.         COMPREPLY=( $( compgen -W '-D -T -E -h -p -U -W -e -q \
  4094.             --location= --template= --encoding= --host= --port= \
  4095.             --username= --password --echo --quiet --help' -- $cur ))
  4096.     else
  4097.         _pg_databases
  4098.     fi
  4099. }
  4100. complete -F _createdb $default createdb
  4101.  
  4102. # dropdb(1) completion
  4103. #
  4104. _dropdb() 
  4105. {
  4106.     local cur prev
  4107.  
  4108.     COMPREPLY=()
  4109.     cur=`_get_cword`
  4110.     prev=${COMP_WORDS[COMP_CWORD-1]}
  4111.  
  4112.     case "$prev" in
  4113.     -@(h|-host=)) 
  4114.         _known_hosts
  4115.         return 0
  4116.         ;;
  4117.     -@(U|-username=))
  4118.         _pg_users
  4119.         return 0
  4120.         ;;
  4121.     esac
  4122.  
  4123.     if [[ "$cur" == -* ]]; then
  4124.         COMPREPLY=( $( compgen -W '-h -p -U -W -e -q \
  4125.                 --host= --port= --username= --password \
  4126.                 --interactive --echo --quiet --help' -- $cur ) )
  4127.     else
  4128.         _pg_databases
  4129.     fi
  4130. }
  4131. complete -F _dropdb $default dropdb
  4132.  
  4133. # psql(1) completion
  4134. #
  4135. _psql() 
  4136. {
  4137.     local cur prev
  4138.  
  4139.     COMPREPLY=()
  4140.     cur=`_get_cword`
  4141.     prev=${COMP_WORDS[COMP_CWORD-1]}
  4142.  
  4143.     case "$prev" in
  4144.     -h|--host) 
  4145.         _known_hosts
  4146.         return 0
  4147.         ;;
  4148.     -U|--username)
  4149.         _pg_users
  4150.         return 0
  4151.         ;;
  4152.     -d|--dbname)
  4153.         _pg_databases
  4154.         return 0
  4155.         ;;
  4156.     -@(o|f)|--output|--file)
  4157.         _filedir
  4158.         return 0
  4159.         ;;
  4160.     esac
  4161.  
  4162.     if [[ "$cur" == -* ]]; then
  4163.         # return list of available options
  4164.         COMPREPLY=( $( compgen -W '-a --echo-all -A --no-align \
  4165.             -c --command -d --dbname -e --echo-queries \
  4166.             -E --echo-hidden -f --file -F --filed-separator \
  4167.             -h --host -H --html -l --list -n -o --output \
  4168.             -p --port -P --pset -q -R --record-separator \
  4169.             -s --single-step -S --single-line -t --tuples-only \
  4170.             -T --table-attr -U --username -v --variable \
  4171.             -V --version -W --password -x --expanded -X --nopsqlrc \
  4172.             -? --help ' -- $cur ) )
  4173.     else
  4174.         # return list of available databases
  4175.         _pg_databases
  4176.     fi
  4177. }
  4178. complete -F _psql $default psql
  4179. }
  4180.  
  4181. _longopt()
  4182. {
  4183.     local cur opt
  4184.  
  4185.     cur=`_get_cword`
  4186.  
  4187.     if [[ "$cur" == --*=* ]]; then
  4188.         opt=${cur%%=*}
  4189.         # cut backslash that gets inserted before '=' sign
  4190.         opt=${opt%\\*}
  4191.         cur=${cur#*=}
  4192.         _filedir
  4193.         COMPREPLY=( $( compgen -P "$opt=" -W '${COMPREPLY[@]}' -- $cur))
  4194.         return 0
  4195.     fi
  4196.  
  4197.     if [[ "$cur" == -* ]]; then
  4198.         COMPREPLY=( $( $1 --help 2>&1 | sed -e '/--/!d' \
  4199.                 -e 's/.*\(--[-A-Za-z0-9]\+=\?\).*/\1/' | \
  4200.                    command grep "^$cur" | sort -u ) )
  4201.     elif [[ "$1" == @(mk|rm)dir ]]; then
  4202.         _filedir -d
  4203.     else
  4204.         _filedir
  4205.     fi
  4206. }
  4207. # makeinfo and texi2dvi are defined elsewhere.
  4208. for i in a2ps autoconf automake bc gprof ld nm objcopy objdump readelf strip \
  4209.      bison cpio diff patch enscript cp df dir du ln ls mkfifo mknod mv rm \
  4210.      touch vdir awk gperf grep grub indent less m4 sed shar date \
  4211.      tee who texindex cat csplit cut expand fmt fold head \
  4212.      md5sum nl od paste pr ptx sha1sum sort split tac tail tr unexpand \
  4213.      uniq wc ldd bash id irb mkdir rmdir; do
  4214.   have $i && complete -F _longopt $filenames $i
  4215. done
  4216.  
  4217. # These commands use filenames, so '-o filenames' is not needed.
  4218. for i in env netstat seq uname units wget; do
  4219.   have $i && complete -F _longopt $default $i
  4220. done
  4221. unset i
  4222.  
  4223. # gcc(1) completion
  4224. #
  4225. # The only unusual feature is that we don't parse "gcc --help -v" output
  4226. # directly, because that would include the options of all the other backend
  4227. # tools (linker, assembler, preprocessor, etc) without any indication that
  4228. # you cannot feed such options to the gcc driver directly.  (For example, the
  4229. # linker takes a -z option, but you must type -Wl,-z for gcc.)  Instead, we
  4230. # ask the driver ("g++") for the name of the compiler ("cc1"), and parse the
  4231. # --help output of the compiler.
  4232. #
  4233. have gcc &&
  4234. _gcc()
  4235. {
  4236.     local cur cc backend
  4237.  
  4238.     COMPREPLY=()
  4239.     cur=`_get_cword`
  4240.  
  4241.     _expand || return 0
  4242.  
  4243.     case "$1" in
  4244.     gcj)
  4245.         backend=jc1
  4246.         ;;
  4247.     gpc)
  4248.         backend=gpc1
  4249.         ;;
  4250.     *77)
  4251.         backend=f771
  4252.         ;;
  4253.     *)
  4254.         backend=cc1    # (near-)universal backend
  4255.         ;;
  4256.     esac
  4257.  
  4258.     if [[ "$cur" == -* ]]; then
  4259.         cc=$( $1 -print-prog-name=$backend )
  4260.         # sink stderr:
  4261.         # for C/C++/ObjectiveC it's useless
  4262.         # for FORTRAN/Java it's an error
  4263.         COMPREPLY=( $( $cc --help 2>/dev/null | tr '\t' ' ' | \
  4264.                    sed -e '/^  *-/!d' -e 's/ *-\([^ ]*\).*/-\1/' | \
  4265.                    command grep "^$cur" | sort -u ) )
  4266.     else
  4267.         _filedir
  4268.     fi
  4269. } &&
  4270. complete $filenames -F _gcc gcc g++ c++ g77 gcj gpc
  4271. [ $UNAME = GNU -o $UNAME = Linux -o $UNAME = Cygwin ] && \
  4272. [ -n "${have:-}" ] && complete $filenames -F _gcc cc
  4273.  
  4274. # Linux cardctl(8) completion
  4275. #
  4276. have cardctl &&
  4277. _cardctl()
  4278. {
  4279.     local cur
  4280.  
  4281.     COMPREPLY=()
  4282.     cur=`_get_cword`
  4283.  
  4284.     if [ $COMP_CWORD -eq 1 ]; then
  4285.         COMPREPLY=( $( compgen -W 'status config ident suspend \
  4286.                        resume reset eject insert scheme' \
  4287.                    -- $cur ) )
  4288.     fi
  4289. } &&
  4290. complete -F _cardctl cardctl
  4291.  
  4292. # This function is required by _dpkg() and _dpkg-reconfigure()
  4293. #
  4294. have dpkg && {
  4295. _comp_dpkg_installed_packages()
  4296. {
  4297.     grep -A 1 "Package: $1" /var/lib/dpkg/status | \
  4298.         grep -B 1 -E "ok installed|half-installed|unpacked| \
  4299.                          half-configured|config-files" | \
  4300.             grep "Package: $1" | cut -d\  -f2
  4301. }
  4302.  
  4303. # Debian dpkg(8) completion
  4304. #
  4305. _dpkg()
  4306. {
  4307.     local cur prev i
  4308.  
  4309.     COMPREPLY=()
  4310.     cur=`_get_cword`
  4311.     prev=${COMP_WORDS[COMP_CWORD-1]}
  4312.     i=$COMP_CWORD
  4313.  
  4314.     _expand || return 0
  4315.  
  4316.     # find the last option flag
  4317.     if [[ $cur != -* ]]; then
  4318.         while [[ $prev != -* && $i != 1 ]]; do
  4319.             i=$((i-1))
  4320.             prev=${COMP_WORDS[i-1]}
  4321.         done
  4322.     fi
  4323.  
  4324.     case "$prev" in 
  4325.     -@(c|i|A|I|f|e|x|X|-@(install|unpack|record-avail|contents|info|fsys-tarfile|field|control|extract)))
  4326.         _filedir '?(u)deb'
  4327.         return 0
  4328.         ;;
  4329.     -@(b|-build))
  4330.         _filedir -d
  4331.         return 0
  4332.         ;;
  4333.        -@(s|p|l|-@(status|print-avail|list)))
  4334.         COMPREPLY=( $( apt-cache pkgnames $cur 2>/dev/null ) )
  4335.         return 0
  4336.         ;;
  4337.     -@(S|-search))
  4338.         _filedir
  4339.         return 0
  4340.         ;;
  4341.     -@(r|L|P|-@(remove|purge|listfiles)))
  4342.         COMPREPLY=( $( _comp_dpkg_installed_packages $cur ) )
  4343.         return 0
  4344.         ;;
  4345.     *)
  4346.  
  4347.     COMPREPLY=( $( compgen -W '-i --install --unpack -A --record-avail \
  4348.             --configure -r --remove -P --purge --get-selections \
  4349.             --set-selections --update-avail --merge-avail \
  4350.             --clear-avail  --command-fd --forget-old-unavail -s \
  4351.             --status -p --print-avail -L --listfiles -l --list \
  4352.             -S --search -C --audit --print-architecture \
  4353.             --print-gnu-build-architecture \
  4354.             --print-installation-architecture \
  4355.             --compare-versions --help --version --force-help \
  4356.             --force-all --force-auto-select --force-downgrade \
  4357.             --force-configure-any --force-hold --force-bad-path \
  4358.             --force-not-root --force-overwrite \
  4359.             --force-overwrite-diverted --force-bad-verify \
  4360.             --force-depends-version --force-depends \
  4361.             --force-confnew --force-confold --force-confdef \
  4362.             --force-confmiss --force-conflicts --force-architecture\
  4363.             --force-overwrite-dir --force-remove-reinstreq \
  4364.             --force-remove-essential -Dh \
  4365.             --debug=help --licence --admindir= --root= --instdir= \
  4366.             -O --selected-only -E --skip-same-version \
  4367.             -G --refuse-downgrade -B --auto-deconfigure \
  4368.             --no-debsig --no-act -D --debug= --status-fd \
  4369.             -b --build -I --info -f --field -c --contents \
  4370.             -x --extract -X --vextract --fsys-tarfile -e --control \
  4371.             --ignore-depends= --abort-after' -- $cur ) )
  4372.         ;;
  4373.     esac
  4374.  
  4375.  
  4376. }
  4377. complete -F _dpkg $filenames dpkg dpkg-deb
  4378. }
  4379.  
  4380. # Debian GNU dpkg-reconfigure(8) completion
  4381. #
  4382. have dpkg-reconfigure &&
  4383. _dpkg_reconfigure()
  4384. {
  4385.     local cur prev opt
  4386.  
  4387.     COMPREPLY=()
  4388.     cur=`_get_cword`
  4389.     prev=${COMP_WORDS[COMP_CWORD-1]}
  4390.  
  4391.  
  4392.     case "$prev" in
  4393.         -@(f|-frontend))
  4394.         opt=( $( echo /usr/share/perl5/Debconf/FrontEnd/* ) )
  4395.         opt=( ${opt[@]##*/} )
  4396.         opt=( ${opt[@]%.pm} )
  4397.         COMPREPLY=( $( compgen -W '${opt[@]}' -- $cur ) )
  4398.         return 0
  4399.         ;;
  4400.         -@(p|-priority))
  4401.           COMPREPLY=( $( compgen -W 'low medium high critical' -- $cur ) )
  4402.         return 0
  4403.         ;;
  4404.     esac
  4405.  
  4406.     if [[ "$cur" == -* ]]; then
  4407.         COMPREPLY=( $( compgen -W '-f --frontend -p --priority -a --all \
  4408.                        -u --unseen-only -h --help -s --showold \
  4409.                        --force --terse' -- $cur ) )
  4410.     else
  4411.         COMPREPLY=( $( _comp_dpkg_installed_packages $cur ) )
  4412.     fi
  4413. } &&
  4414. complete -F _dpkg_reconfigure $default dpkg-reconfigure
  4415.  
  4416. # Debian dpkg-source completion
  4417. #
  4418. have dpkg-source &&
  4419. _dpkg_source()
  4420. {
  4421.     local cur prev options work i action packopts unpackopts
  4422.  
  4423.     packopts="-c -l -F -V -T -D -U -W -E -sa -i -I -sk -sp -su -sr -ss -sn -sA -sK -sP -sU -sR"
  4424.     unpackopts="-sp -sn -su"
  4425.     options=`echo "-x -b $packopts $unpackopts" | xargs echo | sort -u | xargs echo`
  4426.  
  4427.     COMPREPLY=()
  4428.     if [ "$1" != "dpkg-source" ]; then
  4429.         exit 1
  4430.     fi
  4431.     cur=`_get_cword`
  4432.     prev=${COMP_WORDS[COMP_CWORD-1]}
  4433.     action="options"
  4434.     for (( i=0; i < ${#COMP_WORDS[@]}-1; i++ )); do
  4435.         if [[ ${COMP_WORDS[$i]} == "-x" ]]; then
  4436.             action=unpack
  4437.         elif [[ ${COMP_WORDS[$i]} == "-b" ]]; then
  4438.             action=pack
  4439.         elif [[ ${COMP_WORDS[$i]} == "-h" ]]; then
  4440.             action=help
  4441.         fi
  4442.     done
  4443.     # if currently seeing a complete option, return just itself.
  4444.     for i in $options; do
  4445.         if [ "$cur" = "$i" ]; then
  4446.             COMPREPLY=( "$cur" )
  4447.             return 0
  4448.         fi
  4449.     done
  4450.     case "$action" in
  4451.         "unpack")
  4452.             if [ "$cur" = "-" -o "$cur" = "-s" ]; then
  4453.                 COMPREPLY=( $unpackots )
  4454.                 return 0
  4455.             fi
  4456.             case "$prev" in
  4457.                 "-x")
  4458.                     COMPREPLY=( $( compgen -d -- "$cur" ) \
  4459.                             $( compgen -f -X '!*.dsc' -- "$cur" ) )
  4460.                     return 0
  4461.                     ;;
  4462.                 *)
  4463.                     COMPREPLY=( $unpackopts $(compgen -d -f -- "$cur" ) )
  4464.                     return 0
  4465.                     ;;
  4466.             esac
  4467.             return 0
  4468.             ;;
  4469.         "pack")
  4470.             if [ "$cur" = "-" ]; then
  4471.                 COMPREPLY=( $packopts )
  4472.                 return 0
  4473.             fi
  4474.             if [ "$cur" = "-s" ]; then
  4475.                 COMPREPLY=( "-sa" "-sk" "-sp" "-su" "-sr" "-ss" "-sn" \
  4476.                         "-sA" "-sK" "-sP" "-sU" "-sR" )
  4477.                 return 0
  4478.             fi
  4479.             case "$prev" in
  4480.                 "-b")
  4481.                     COMPREPLY=( $( compgen -d -- "$cur" ) )
  4482.                     return 0
  4483.                     ;;
  4484.                 "-c"|"-l"|"-T"|"-i"|"-I")
  4485.                     # -c: get controlfile
  4486.                     # -l: get per-version info from this file
  4487.                     # -T: read variables here, not debian/substvars
  4488.                     # -i: <regexp> filter out files to ignore diffs of.
  4489.                     # -I: filter out files when building tarballs.
  4490.                     # return directory names and file names
  4491.                     COMPREPLY=( $( compgen -d -f ) )
  4492.                     return 0
  4493.                     ;;
  4494.                 "-F")
  4495.                     # -F: force change log format
  4496.                     COMPREPLY=( $( ( cd /usr/lib/dpkg/parsechangelog; compgen -f "$cur" ) ) )
  4497.                     return 0
  4498.                     ;;
  4499.                 "-V"|"-D")
  4500.                     # -V: set a substitution variable
  4501.                     # we don't know anything about possible variables or values
  4502.                     # so we don't try to suggest any completion.
  4503.                     COMPREPLY=()
  4504.                     return 0
  4505.                     ;;
  4506.                 "-D")
  4507.                     # -D: override or add a .dsc field and value
  4508.                     # if $cur doesn't contain a = yet, suggest variable names
  4509.                     if echo -- "$cur" | grep -q "="; then
  4510.                         # $cur contains a "="
  4511.                         COMPREPLY=()
  4512.                         return 0
  4513.                     else
  4514.                         COMPREPLY=( Format Source Version Binary Maintainer Uploader Architecture Standards-Version Build-Depends Files )
  4515.                         return 0
  4516.                     fi
  4517.                     ;;
  4518.                 "-U")
  4519.                     # -U: remove a field
  4520.                     # Suggest possible fieldnames
  4521.                     COMPREPLY=( Format Source Version Binary Maintainer Uploader Architecture Standards-Version Build-Depends Files )
  4522.                     return 0
  4523.                     ;;
  4524.                 *)
  4525.                     COMPREPLY=( $packopts )
  4526.                     return 0
  4527.                     ;;
  4528.             esac
  4529.             return 0
  4530.             ;;
  4531.         *)
  4532.             # if seeing a partial option, return possible completions.
  4533.             if [ "$cur" = "-s" ]; then
  4534.                 COMPREPLY=( "-sa" "-sk" "-sp" "-su" "-sr" "-ss" "-sn" \
  4535.                         "-sA" "-sK" "-sP" "-sU" "-sR" )
  4536.                 return 0
  4537.             fi
  4538.             # else return all possible options.
  4539.             COMPREPLY=( $options )
  4540.             return 0
  4541.             ;;
  4542.     esac
  4543. } &&
  4544. complete -F _dpkg_source dpkg-source
  4545.  
  4546. # Debian Linux dselect(8) completion.
  4547. #
  4548. have dselect &&
  4549. _dselect()
  4550. {
  4551.     local cur prev
  4552.  
  4553.     COMPREPLY=()
  4554.     cur=`_get_cword`
  4555.     prev=${COMP_WORDS[COMP_CWORD-1]}
  4556.  
  4557.     case "$prev" in
  4558.          --admindir)
  4559.           _filedir -d
  4560.           return 0
  4561.           ;;
  4562.  
  4563.          -@(D|debug))
  4564.           _filedir
  4565.           return 0
  4566.           ;;
  4567.     esac
  4568.  
  4569.     if [[ "$cur" == -* ]]; then
  4570.         COMPREPLY=( $( compgen -W '--admindir --help --version --licence \
  4571.                   --license --expert --debug' -- $cur ) )
  4572.     else
  4573.         COMPREPLY=( $( compgen -W 'access update select install config \
  4574.                   remove quit' -- $cur ) )
  4575.     fi
  4576.  
  4577.  
  4578.     return 0
  4579. } &&
  4580. complete -F _dselect $filenames dselect
  4581.  
  4582. # Java completion
  4583. #
  4584.  
  4585. # available path elements completion
  4586. have java && {
  4587. _java_path()
  4588. {
  4589.     cur=${cur##*:}
  4590.     _filedir '@(jar|zip)'
  4591. }
  4592.  
  4593. # exact classpath determination
  4594. _java_find_classpath()
  4595. {
  4596.     local i
  4597.  
  4598.     # search first in current options
  4599.     for (( i=1; i < COMP_CWORD; i++ )); do
  4600.         if [[ "${COMP_WORDS[i]}" == -@(cp|classpath) ]]; then
  4601.             classpath=${COMP_WORDS[i+1]}
  4602.             break
  4603.         fi
  4604.     done
  4605.  
  4606.     # default to environment
  4607.     [ -z "$classpath" ] && classpath=$CLASSPATH
  4608.  
  4609.     # default to current directory
  4610.     [ -z "$classpath" ] && classpath=.
  4611. }
  4612.  
  4613. # exact sourcepath determination
  4614. _java_find_sourcepath()
  4615. {
  4616.     local i
  4617.  
  4618.     # search first in current options
  4619.     for (( i=1; i < COMP_CWORD; i++ )); do
  4620.         if [[ "${COMP_WORDS[i]}" == -sourcepath ]]; then
  4621.             sourcepath=${COMP_WORDS[i+1]}
  4622.             break
  4623.         fi
  4624.     done
  4625.  
  4626.     # default to classpath
  4627.     [ -z "$sourcepath" ] && _java_find_classpath
  4628.     sourcepath=$classpath
  4629. }
  4630.  
  4631. # available classes completion
  4632. _java_classes()
  4633. {
  4634.     local classpath i
  4635.  
  4636.     # find which classpath to use
  4637.     _java_find_classpath
  4638.  
  4639.     # convert package syntax to path syntax
  4640.     cur=${cur//.//}
  4641.     # parse each classpath element for classes
  4642.     for i in ${classpath//:/ }; do
  4643.         if [ -r $i ] && [[ "$i" == *.@(jar|zip) ]]; then
  4644.             if type zipinfo &> /dev/null; then
  4645.                 COMPREPLY=( "${COMPREPLY[@]}" $( zipinfo -1 \
  4646.                 "$i" | grep "^$cur" | grep '\.class$' | \
  4647.                 grep -v "\\$" ) )
  4648.             else
  4649.                 COMPREPLY=( "${COMPREPLY[@]}" $( jar tf "$i" \
  4650.                 "$cur" | grep "\.class$" | grep -v "\\$" ) )
  4651.             fi
  4652.  
  4653.         elif [ -d $i ]; then
  4654.             i=${i%/}
  4655.             COMPREPLY=( "${COMPREPLY[@]}" $( find "$i" -type f \
  4656.             -path "$i/$cur*.class" 2>/dev/null | \
  4657.             grep -v "\\$" | sed -e "s|^$i/||" ) )
  4658.         fi
  4659.     done
  4660.  
  4661.     # remove class extension
  4662.     COMPREPLY=( ${COMPREPLY[@]%.class} )
  4663.     # convert path syntax to package syntax
  4664.     COMPREPLY=( ${COMPREPLY[@]//\//.} )
  4665. }
  4666.  
  4667. # available packages completion
  4668. _java_packages()
  4669. {
  4670.     local sourcepath i
  4671.  
  4672.     # find wich sourcepath to use
  4673.     _java_find_sourcepath
  4674.  
  4675.     # convert package syntax to path syntax
  4676.     cur=${cur//.//}
  4677.     # parse each sourcepath element for packages
  4678.     for i in ${sourcepath//:/ }; do
  4679.         if [ -d $i ]; then
  4680.             COMPREPLY=( "${COMPREPLY[@]}" $( command ls -F -d \
  4681.                 $i/$cur* 2>/dev/null | sed -e 's|^'$i'/||' ) )
  4682.         fi
  4683.     done
  4684.     # keep only packages
  4685.     COMPREPLY=( $( echo "${COMPREPLY[@]}" | tr " " "\n" | grep "/$" ) )
  4686.     # remove packages extension
  4687.     COMPREPLY=( ${COMPREPLY[@]%/} )
  4688.     # convert path syntax to package syntax
  4689.     cur=${COMPREPLY[@]//\//.}
  4690. }
  4691.  
  4692. # java completion
  4693. #
  4694. _java()
  4695. {
  4696.     local cur prev i
  4697.  
  4698.     COMPREPLY=()
  4699.     cur=`_get_cword`
  4700.     prev=${COMP_WORDS[COMP_CWORD-1]}
  4701.  
  4702.     for ((i=1; i < $COMP_CWORD; i++)); do
  4703.         case ${COMP_WORDS[$i]} in
  4704.             -cp|-classpath)
  4705.             ((i++))    # skip the classpath string.
  4706.             ;;
  4707.             -*)
  4708.             # this is an option, not a class/jarfile name.
  4709.             ;;
  4710.             *)
  4711.             # once we've seen a class, just do filename completion
  4712.             _filedir
  4713.             return 0
  4714.             ;;
  4715.         esac
  4716.     done
  4717.  
  4718.     case $prev in
  4719.         -@(cp|classpath))
  4720.             _java_path
  4721.             return 0
  4722.             ;;
  4723.     esac
  4724.  
  4725.     if [[ "$cur" == -* ]]; then
  4726.         # relevant options completion
  4727.         COMPREPLY=( $( compgen -W '-client -hotspot -server -classic \
  4728.                 -cp -classpath -D -verbose -verbose:class \
  4729.                 -verbose:gc -version:jni -version \
  4730.                 -showversion -? -help -X -jar \
  4731.                 -ea -enableassertions -da -disableassertions \
  4732.                 -esa -enablesystemassertions \
  4733.                 -dsa -disablesystemassertions ' -- $cur ) )
  4734.     else
  4735.         if [[ "$prev" == -jar ]]; then
  4736.             # jar file completion
  4737.             _filedir jar
  4738.         else
  4739.             # classes completion
  4740.             _java_classes
  4741.         fi
  4742.     fi
  4743. }
  4744. complete -F _java $filenames java
  4745. }
  4746.  
  4747. # javadoc completion
  4748. #
  4749. have javadoc &&
  4750. _javadoc()
  4751. {
  4752.     COMPREPLY=()
  4753.     local cur prev
  4754.  
  4755.     cur=`_get_cword`
  4756.     prev=${COMP_WORDS[COMP_CWORD-1]}
  4757.  
  4758.     case $prev in
  4759.         -@(overview|helpfile|stylesheetfile))
  4760.             _filedir
  4761.             return 0
  4762.             ;;
  4763.         -d)
  4764.             _filedir -d
  4765.             return 0
  4766.             ;;
  4767.         -@(classpath|bootclasspath|docletpath|sourcepath|extdirs))
  4768.             _java_path
  4769.             return 0
  4770.             ;;
  4771.     esac
  4772.  
  4773.     if [[ "$cur" == -* ]]; then
  4774.         # relevant options completion
  4775.         COMPREPLY=( $( compgen -W '-overview -public -protected \
  4776.                 -package -private -help -doclet -docletpath \
  4777.                 -sourcepath -classpath -exclude -subpackages \
  4778.                 -breakiterator -bootclasspath -source -extdirs \
  4779.                 -verbose -locale -encoding -J -d -use -version \
  4780.                 -author -docfilessubdirs -splitindex \
  4781.                 -windowtitle -doctitle -header -footer -bottom \
  4782.                 -link -linkoffline -excludedocfilessubdir \
  4783.                 -group -nocomment -nodeprecated -noqualifier \
  4784.                 -nosince -nodeprecatedlist -notree -noindex \
  4785.                 -nohelp -nonavbar -quiet -serialwarn -tag \
  4786.                 -taglet -tagletpath -charset -helpfile \
  4787.                 -linksource -stylesheetfile -docencoding' -- \
  4788.                 $cur ) )
  4789.     else
  4790.         # source files completion
  4791.         _filedir java
  4792.         # packages completion
  4793.         _java_packages
  4794.     fi
  4795. } &&
  4796. complete -F _javadoc $filenames javadoc
  4797.  
  4798. # javac completion
  4799. #
  4800. have javac &&
  4801. _javac()
  4802. {
  4803.     COMPREPLY=()
  4804.     local cur prev
  4805.  
  4806.     cur=`_get_cword`
  4807.     prev=${COMP_WORDS[COMP_CWORD-1]}
  4808.  
  4809.     case $prev in
  4810.         -d)
  4811.             _filedir -d
  4812.             return 0
  4813.             ;;
  4814.         -@(classpath|bootclasspath|sourcepath|extdirs))
  4815.             _java_path
  4816.             return 0
  4817.             ;;
  4818.     esac
  4819.  
  4820.     if [[ "$cur" == -* ]]; then
  4821.         # relevant options completion
  4822.         COMPREPLY=( $( compgen -W '-g -g:none -g:lines -g:vars\
  4823.         -g:source -O -nowarn -verbose -deprecation -classpath\
  4824.         -sourcepath -bootclasspath -extdirs -d -encoding -source\
  4825.         -target -help' -- $cur ) )
  4826.     else
  4827.         # source files completion
  4828.         _filedir java
  4829.     fi
  4830. } &&
  4831. complete -F _javac $filenames javac
  4832.  
  4833. # PINE address-book completion
  4834. #
  4835. have pine &&
  4836. _pineaddr()
  4837. {
  4838.     local cur
  4839.  
  4840.     COMPREPLY=()
  4841.     cur=`_get_cword`
  4842.  
  4843.     COMPREPLY=( $( compgen -W '$( awk "{print \$1}" ~/.addressbook 2>/dev/null)' \
  4844.             -- $cur ) )
  4845. } &&
  4846. complete -F _pineaddr $default pine
  4847.  
  4848. # mutt completion
  4849. #
  4850. # Mutt doesn't have an "addressbook" like Pine, but it has aliases and
  4851. # a "query" function to retrieve addresses, so that's what we use here.
  4852. have mutt || have muttng && {
  4853. _muttaddr()
  4854. {
  4855.     _muttaliases
  4856.     _muttquery
  4857.     return 0
  4858. }
  4859.  
  4860. _muttconffiles()
  4861. {
  4862.     local file sofar
  4863.     local -a newconffiles
  4864.  
  4865.     sofar=" $1 "
  4866.     shift
  4867.     while [[ "$1" ]]; do
  4868.         newconffiles=( $(sed -rn 's|^source[[:space:]]+([^[:space:]]+).*$|\1|p' $(eval echo $1) ) )
  4869.         for file in "${newconffiles[@]}"; do
  4870.         [[ ! "$file" ]] || [[ "${sofar/ ${file} / }" != "$sofar" ]] &&
  4871.             continue
  4872.         sofar="$sofar $file"
  4873.         sofar=" $(eval _muttconffiles \"$sofar\" $file) "
  4874.         done
  4875.         shift
  4876.     done
  4877.     echo $sofar
  4878. }
  4879.  
  4880. _muttaliases()
  4881. {
  4882.     local cur muttrc
  4883.     local -a conffiles aliases
  4884.     cur=`_get_cword`
  4885.  
  4886.     [ -f ~/.${muttcmd}/${muttcmd}rc ] && muttrc="~/.${muttcmd}/${muttcmd}rc"
  4887.     [ -f ~/.${muttcmd}rc ] && muttrc="~/.${muttcmd}rc"
  4888.     [ -z "$muttrc" ] && return 0
  4889.  
  4890.     conffiles=( $(eval _muttconffiles $muttrc $muttrc) )
  4891.     aliases=( $( sed -rn 's|^alias[[:space:]]+([^[:space:]]+).*$|\1|p' \
  4892.             $(eval echo "${conffiles[@]}") ) )
  4893.     COMPREPLY=( "${COMPREPLY[@]}" $( compgen -W "${aliases[*]}" -- $cur ) )
  4894.  
  4895.     return 0
  4896. }
  4897.  
  4898. _muttquery()
  4899. {
  4900.     local cur querycmd
  4901.     local -a queryresults
  4902.     cur=`_get_cword`
  4903.  
  4904.     querycmd="$( $muttcmd -Q query_command  | sed -r 's|^query_command=\"(.*)\"$|\1|; s|%s|'$cur'|' )"
  4905.     if [ -z "$cur" -o -z "$querycmd" ]; then
  4906.         queryresults=()
  4907.     else 
  4908.         queryresults=( $( $querycmd | \
  4909.           sed -nr '2,$s|^([^[:space:]]+).*|\1|p' ) )
  4910.     fi
  4911.  
  4912.     COMPREPLY=( "${COMPREPLY[@]}" $( compgen -W "${queryresults[*]}" \
  4913.             -- $cur ) )
  4914.  
  4915.     return 0
  4916. }
  4917.  
  4918. _muttfiledir()
  4919. {
  4920.     local cur folder spoolfile
  4921.     cur=`_get_cword`
  4922.  
  4923.     # This is currently not working so well. Perhaps this function should
  4924.     # just call _filedir() for the moment.
  4925.     if [[ $cur == [=+]* ]]; then
  4926.         folder="$( $muttcmd -Q folder | sed -r 's|^folder=\"(.*)\"$|\1|' )"
  4927.         : folder:=~/Mail
  4928.  
  4929.         # Match any file in $folder beginning with $cur
  4930.         # (minus the leading '=' sign).
  4931.         COMPREPLY=( $( compgen -f -- "$folder/${cur:1}" ) )
  4932.         COMPREPLY=( ${COMPREPLY[@]#$folder/} )
  4933.         return 0
  4934.     elif [ "$cur" == !* ]; then
  4935.         spoolfile="$( $muttcmd -Q spoolfile | sed -r 's|^spoolfile=\"(.*)\"$|\1|' )"
  4936.         [ ! -z "$spoolfile" ] && eval cur="${cur/^!/$spoolfile}";
  4937.     fi
  4938.     _filedir
  4939.  
  4940.     return 0
  4941. }
  4942.  
  4943. _mutt()
  4944. {
  4945.     local cur prev
  4946.     cur=`_get_cword`
  4947.     prev=${COMP_WORDS[COMP_CWORD-1]}
  4948.  
  4949.     COMPREPLY=()
  4950.     
  4951.     [ ${COMP_WORDS[0]} == muttng ] && muttcmd="muttng" || muttcmd="mutt"
  4952.  
  4953.     case "$cur" in
  4954.     -*)
  4955.         COMPREPLY=( $( compgen -W '-A -a -b -c -e -f -F -H -i -m -n \
  4956.                         -p -Q -R -s -v -x -y -z -Z -h' \
  4957.                         -- $cur ) )
  4958.         return 0
  4959.         ;;
  4960.     *)
  4961.         case "$prev" in
  4962.         -@(a|f|F|H|i))
  4963.             _muttfiledir
  4964.             return 0
  4965.             ;;
  4966.         -A)
  4967.             _muttaliases
  4968.             return 0
  4969.             ;;
  4970.         -@(e|m|Q|s|h|p|R|v|y|z|Z))
  4971.             return 0
  4972.             ;;
  4973.         *)
  4974.             _muttaddr
  4975.             return 0
  4976.             ;;
  4977.         esac
  4978.         ;;
  4979.     esac
  4980.     
  4981. }
  4982. complete -F _mutt $default $filenames mutt muttng
  4983. }
  4984.  
  4985. _configure_func()
  4986. {
  4987.     local cur
  4988.  
  4989.     COMPREPLY=()
  4990.     cur=`_get_cword`
  4991.  
  4992.     # if $COMP_CONFIGURE_HINTS is not null, then completions of the form
  4993.     # --option=SETTING will include 'SETTING' as a contextual hint
  4994.     [[ "$cur" != -* ]] && return 0
  4995.  
  4996.     if [ -n "$COMP_CONFIGURE_HINTS" ]; then
  4997.         COMPREPLY=( $( $1 --help | awk '/^  --[A-Za-z]/ { print $1; if ($2 ~ /--[A-Za-z]/) print $2 }' | sed -e 's/[[,].*//g' | grep ^$cur ) )
  4998.  
  4999.     else
  5000.         COMPREPLY=( $( $1 --help | awk '/^  --[A-Za-z]/ { print $1; if ($2 ~ /--[A-Za-z]/) print $2 }' | sed -e 's/[[,=].*//g' | grep ^$cur ) )
  5001.     fi
  5002. }
  5003. complete -F _configure_func $default configure
  5004.  
  5005. # Debian reportbug(1) completion
  5006. #
  5007. have reportbug &&
  5008. _reportbug()
  5009. {
  5010.     local cur prev
  5011.  
  5012.     COMPREPLY=()
  5013.     cur=`_get_cword`
  5014.     prev=${COMP_WORDS[COMP_CWORD-1]}
  5015.  
  5016.     case "$prev" in
  5017.         -f|--filename|-i|--include|--mta|-o|--output)
  5018.         _filedir
  5019.         return 0
  5020.         ;;
  5021.         -B|--bts)
  5022.         COMPREPLY=( $( compgen -W "debian guug kde mandrake help" -- \
  5023.                    $cur ))
  5024.         return 0
  5025.         ;;
  5026.         -e|--editor|--mua)
  5027.         COMP_WORDS=(COMP_WORDS[0] $cur)
  5028.         COMP_CWORD=1
  5029.         _command
  5030.         return 0
  5031.         ;;
  5032.         --mode)
  5033.         COMPREPLY=( $( compgen -W "novice standard expert" -- $cur ) )
  5034.         return 0
  5035.         ;;
  5036.         -S|--severity)
  5037.         COMPREPLY=( $( compgen -W "grave serious important normal \
  5038.                        minor wishlist" -- $cur ) )
  5039.         return 0
  5040.         ;;
  5041.         -u|--ui|--interface)
  5042.         COMPREPLY=( $( compgen -W "newt text gnome" -- $cur ) )
  5043.         return 0
  5044.         ;;
  5045.         -t|--type)
  5046.         COMPREPLY=( $( compgen -W "gnats debbugs" -- $cur ) )
  5047.         return 0
  5048.         ;;
  5049.         -T|--tags)
  5050.         COMPREPLY=( $( compgen -W "none patch security upstream sid \
  5051.                        woody potato sarge fixed" -- $cur ))
  5052.         return 0
  5053.         ;;
  5054.         *)
  5055.         ;;
  5056.     esac
  5057.     
  5058.     COMPREPLY=($( compgen -W '-h --help -v --version -a --af -b \
  5059.             --no-query-bts --query-bts -B --bts -c --configure \
  5060.             --no-config-files --check-available -d --debug \
  5061.             --no-check-available -e --editor --email -f \
  5062.             --filename -g --gnupg -H --header -i --include -j \
  5063.             --justification -l --ldap --no-ldap -L --list-cc -m \
  5064.             --maintonly --mode --mua --mta --mutt -n --mh --nmh \
  5065.             -o --output -p --print -P --pgp --proxy --http_proxy\
  5066.             -q --quiet -Q --query-only --realname --report-quiet \
  5067.             --reply-to --replyto -s --subject -S --severity \
  5068.             --smtphost -t --type -T --tags --template -V -x \
  5069.             --no-cc --package-version -z --no-compress \
  5070.             --ui --interface -u \
  5071.             wnpp boot-floppies kernel-image' -- $cur ) \
  5072.                 $( apt-cache pkgnames -- $cur 2> /dev/null ) )
  5073.     _filedir
  5074.     return 0
  5075. } &&
  5076. complete -F _reportbug $filenames reportbug
  5077.  
  5078. # Debian querybts(1) completion
  5079. #
  5080. have querybts &&
  5081. _querybts()
  5082. {
  5083.     local cur prev
  5084.  
  5085.     COMPREPLY=()
  5086.     cur=`_get_cword`
  5087.     prev=${COMP_WORDS[COMP_CWORD-1]}
  5088.  
  5089.     case "$prev" in
  5090.         -B|--bts)
  5091.         COMPREPLY=( $( compgen -W "debian guug kde mandrake help" -- \
  5092.                    $cur ))
  5093.         return 0
  5094.         ;;
  5095.         -u|--ui|--interface)
  5096.         COMPREPLY=($( compgen -W "newt text gnome" -- $cur ))
  5097.         return 0
  5098.         ;;
  5099.         *)
  5100.         ;;
  5101.     esac
  5102.  
  5103.     COMPREPLY=($( compgen -W '-h --help -v --version -A --archive \
  5104.             -B --bts -l --ldap --no-ldap --proxy= --http_proxy= \
  5105.             -s --source -w --web -u --ui --interface \
  5106.             wnpp boot-floppies' -- $cur ) \
  5107.                 $( apt-cache pkgnames -- $cur 2> /dev/null ) )
  5108. } &&
  5109. complete -F _querybts $filenames querybts
  5110.  
  5111. # update-alternatives completion
  5112. #
  5113. have update-alternatives && {
  5114. installed_alternatives()
  5115. {
  5116.     local admindir
  5117.     # find the admin dir
  5118.     for i in alternatives dpkg/alternatives rpm/alternatives; do
  5119.         [ -d /var/lib/$i ] && admindir=/var/lib/$i && break
  5120.     done
  5121.     for (( i=1; i < COMP_CWORD; i++ )); do
  5122.         if [[ "${COMP_WORDS[i]}" == --admindir ]]; then
  5123.             admindir=${COMP_WORDS[i+1]}
  5124.             break
  5125.         fi
  5126.     done
  5127.     COMPREPLY=( $( command ls $admindir | grep "^$cur" ) )
  5128. }
  5129.  
  5130. _update_alternatives()
  5131. {
  5132.     local cur prev mode args i
  5133.  
  5134.     COMPREPLY=()
  5135.     cur=`_get_cword`
  5136.     prev=${COMP_WORDS[COMP_CWORD-1]}
  5137.  
  5138.     case "$prev" in
  5139.     --@(altdir|admindir))
  5140.         _filedir -d
  5141.         return 0
  5142.         ;;
  5143.     --@(help|version))
  5144.         return 0
  5145.         ;;
  5146.     esac
  5147.  
  5148.     # find wich mode to use and how many real args used so far
  5149.     for (( i=1; i < COMP_CWORD; i++ )); do
  5150.         if [[ "${COMP_WORDS[i]}" == --@(install|remove|auto|display|config|remove-all) ]]; then
  5151.             mode=${COMP_WORDS[i]}
  5152.             args=$(($COMP_CWORD - i))
  5153.             break
  5154.         fi
  5155.     done
  5156.  
  5157.     case $mode in
  5158.     --install)
  5159.         case $args in
  5160.         1)
  5161.             _filedir
  5162.             ;;
  5163.         2)
  5164.             installed_alternatives
  5165.             ;;
  5166.         3)
  5167.             _filedir
  5168.             ;;
  5169.         esac
  5170.         ;;
  5171.     --remove)
  5172.         case $args in
  5173.         1)
  5174.             installed_alternatives
  5175.             ;;
  5176.         2)
  5177.             _filedir
  5178.             ;;
  5179.         esac
  5180.         ;;
  5181.     --auto)
  5182.         installed_alternatives
  5183.         ;;
  5184.     --remove-all)
  5185.         installed_alternatives
  5186.         ;;
  5187.     --display)
  5188.         installed_alternatives
  5189.         ;;
  5190.     --config)
  5191.         installed_alternatives
  5192.         ;;
  5193.     *)
  5194.         COMPREPLY=( $( compgen -W '--verbose --quiet --help --version \
  5195.                    --altdir --admindir' -- $cur ) \
  5196.                 $( compgen -W '--install --remove --auto --display \
  5197.                    --config' -- $cur ) )
  5198.     esac
  5199. }
  5200. complete -F _update_alternatives update-alternatives
  5201. }
  5202.  
  5203. # Python completion
  5204. #
  5205. have python &&
  5206. _python()
  5207. {
  5208.     local prev cur
  5209.  
  5210.     COMPREPLY=()
  5211.     cur=`_get_cword`
  5212.     prev=${COMP_WORDS[COMP_CWORD-1]##*/}
  5213.  
  5214.     case "$prev" in
  5215.     -Q)
  5216.         COMPREPLY=( $( compgen -W "old new warn warnall" -- $cur ) )
  5217.         return 0
  5218.         ;;
  5219.     -W)
  5220.         COMPREPLY=( $( compgen -W "ignore default all module once error" -- $cur ) )
  5221.         return 0
  5222.         ;;
  5223.     -c)
  5224.         _filedir '@(py|pyc|pyo)'
  5225.         return 0
  5226.         ;;
  5227.     !(python|-?))
  5228.         [[ ${COMP_WORDS[COMP_CWORD-2]} != -@(Q|W) ]] && _filedir
  5229.         ;;
  5230.     esac
  5231.  
  5232.  
  5233.     # if '-c' is already given, complete all kind of files.
  5234.     for (( i=0; i < ${#COMP_WORDS[@]}-1; i++ )); do
  5235.         if [[ ${COMP_WORDS[i]} == -c ]]; then
  5236.             _filedir
  5237.         fi
  5238.     done
  5239.  
  5240.  
  5241.     if [[ "$cur" != -* ]]; then
  5242.         _filedir '@(py|pyc|pyo)'
  5243.     else
  5244.         COMPREPLY=( $( compgen -W "- -d -E -h -i -O -Q -S -t -u \
  5245.                        -U -v -V -W -x -c" -- $cur ) )
  5246.     fi
  5247.  
  5248.  
  5249.  
  5250.     return 0
  5251. } &&
  5252. complete -F _python $filenames python
  5253.  
  5254. # Perl completion
  5255. #
  5256. have perl &&
  5257. {
  5258. _perlmodules()
  5259. {
  5260.     COMPREPLY=( $( compgen -P "$prefix" -W "$( perl -e 'sub mods { my ($base,$dir)=@_; return if  $base !~ /^\Q$ENV{cur}/; chdir($dir) or return; for (glob(q[*.pm])) {s/\.pm$//; print qq[$base$_\n]}; mods(/^(?:[.\d]+|$Config{archname}-$Config{osname}|auto)$/ ? undef : qq[${base}${_}\\\\:\\\\:],qq[$dir/$_]) for grep {-d} glob(q[*]); } mods(undef,$_) for @INC;' )" -- $cur ) )
  5261. }
  5262.  
  5263. _perl()
  5264. {
  5265.     local cur prev prefix temp
  5266.  
  5267.     COMPREPLY=()
  5268.     cur=`_get_cword`
  5269.     prev=${COMP_WORDS[COMP_CWORD-1]}
  5270.     prefix=""
  5271.  
  5272.     # completing an option (may or may not be separated by a space)
  5273.     if [[ "$cur" == -?* ]]; then
  5274.     temp=$cur
  5275.     prev=${temp:0:2}
  5276.     cur=${temp:2}
  5277.     prefix=$prev
  5278.     fi
  5279.  
  5280.     # only handle module completion for now
  5281.     case "$prev" in
  5282.         -I|-x)
  5283.         COMPREPLY=( $( compgen -d -P "$prev" -- "$cur" ) )
  5284.         return 0
  5285.         ;;
  5286.     -m|-M)
  5287.         _perlmodules
  5288.         return 0
  5289.         ;;
  5290.     esac
  5291.  
  5292.     # handle case where first parameter is not a dash option
  5293.     if [[ "${COMP_WORDS[COMP_CWORD]}" != -* ]]; then
  5294.     _filedir
  5295.     return 0
  5296.     fi
  5297.  
  5298.     # complete using basic options
  5299.     COMPREPLY=( $( compgen -W '-C -s -T -u -U -W -X -h -v -V -c -w -d -D -p \
  5300.             -n -a -F -l -0 -I -m -M -P -S -x -i -e ' -- $cur ) )
  5301.     return 0
  5302. }
  5303. complete -F _perl $filenames perl
  5304.  
  5305. _perldoc()
  5306. {
  5307.     local cur prev prefix temp
  5308.  
  5309.     COMPREPLY=()
  5310.     cur=`_get_cword`
  5311.     prev=${COMP_WORDS[COMP_CWORD-1]}
  5312.     prefix=""
  5313.  
  5314.     # completing an option (may or may not be separated by a space)
  5315.     if [[ "$cur" == -?* ]]; then
  5316.     temp=$cur
  5317.     prev=${temp:0:2}
  5318.     cur=${temp:2}
  5319.     prefix=$prev
  5320.     fi
  5321.  
  5322.     # complete builtin perl functions
  5323.     case $prev in
  5324.     -f)
  5325.         COMPREPLY=( $( compgen -W 'chomp chop chr crypt hex index lc \
  5326.         lcfirst length oct ord pack q qq reverse rindex sprintf \
  5327.         substr tr uc ucfirst y m pos quotemeta s split study qr abs \
  5328.         atan2 cos exp hex int log oct rand sin sqrt srand pop push \
  5329.         shift splice unshift grep join map qw reverse sort unpack \
  5330.         delete each exists keys values binmode close closedir \
  5331.         dbmclose dbmopen die eof fileno flock format getc print \
  5332.         printf read readdir rewinddir seek seekdir select syscall \
  5333.         sysread sysseek syswrite tell telldir truncate warn write \
  5334.         pack read syscall sysread syswrite unpack vec -X chdir chmod \
  5335.         chown chroot fcntl glob ioctl link lstat mkdir open opendir \
  5336.         readlink rename rmdir stat symlink umask unlink utime caller \
  5337.         continue do dump eval exit goto last next redo return \
  5338.         sub wantarray caller import local my our package use defined \
  5339.         formline reset scalar undef \
  5340.         alarm exec fork getpgrp getppid getpriority kill pipe qx \
  5341.         setpgrp setpriority sleep system times wait waitpid \
  5342.         import no package require use bless dbmclose dbmopen package \
  5343.         ref tie tied untie use accept bind connect getpeername \
  5344.         getsockname getsockopt listen recv send setsockopt shutdown \
  5345.         socket socketpair msgctl msgget msgrcv msgsnd semctl semget \
  5346.         semop shmctl shmget shmread shmwrite endgrent endhostent \
  5347.         endnetent endpwent getgrent getgrgid getgrnam getlogin \
  5348.         getpwent getpwnam getpwuid setgrent setpwent endprotoent \
  5349.         endservent gethostbyaddr gethostbyname gethostent \
  5350.         getnetbyaddr getnetbyname getnetent getprotobyname \
  5351.         getprotobynumber getprotoent getservbyname getservbyport \
  5352.         getservent sethostent setnetent setprotoent setservent \
  5353.         gmtime localtime time times' -- $cur ) )
  5354.         return 0
  5355.         ;;
  5356.     esac
  5357.  
  5358.     case $cur in
  5359.     -*)
  5360.         COMPREPLY=( $( compgen -W '-h -v -t -u -m -l -F -X -f -q' -- $cur ))
  5361.         return 0
  5362.         ;;
  5363.     */*)
  5364.         return 0
  5365.         ;;
  5366.     *)
  5367.         _perlmodules
  5368.         COMPREPLY=( "${COMPREPLY[@]}" $( compgen -W '$( PAGER=cat man perl 2>/dev/null | sed -ne "/perl.*Perl overview/,/perlwin32/s/^[^a-z0-9]*\([a-z0-9]*\).*$/\1/p")' -- $cur ) )
  5369.  
  5370.         return 0
  5371.         ;;
  5372.     esac
  5373. }
  5374. complete -F _perldoc $default perldoc
  5375. }
  5376.  
  5377. # rcs(1) completion
  5378. #
  5379. have rcs &&
  5380. _rcs()
  5381. {
  5382.     local cur prev file dir i
  5383.  
  5384.     COMPREPLY=()
  5385.     cur=`_get_cword`
  5386.     prev=${COMP_WORDS[COMP_CWORD-1]}
  5387.  
  5388.     file=${cur##*/}
  5389.     dir=${cur%/*}
  5390.  
  5391.     # deal with relative directory
  5392.     [ "$file" = "$dir" ] && dir=.
  5393.  
  5394.     COMPREPLY=( $( compgen -f "$dir/RCS/$file" ) )
  5395.  
  5396.     for (( i=0; i < ${#COMPREPLY[@]}; i++ )); do
  5397.         file=${COMPREPLY[$i]##*/}
  5398.         dir=${COMPREPLY[$i]%RCS/*}
  5399.         COMPREPLY[$i]=$dir$file
  5400.     done
  5401.     
  5402.     COMPREPLY=( "${COMPREPLY[@]}" $( compgen -G "$dir/$file*,v" ) )
  5403.  
  5404.     for (( i=0; i < ${#COMPREPLY[@]}; i++ )); do
  5405.         COMPREPLY[$i]=${COMPREPLY[$i]%,v}
  5406.     done
  5407.  
  5408.     # default to files if nothing returned and we're checking in.
  5409.     # otherwise, default to directories
  5410.     [ ${#COMPREPLY[@]} -eq 0 -a $1 = ci ] && _filedir || _filedir -d
  5411. } &&
  5412. complete -F _rcs $filenames ci co rlog rcs rcsdiff
  5413.  
  5414. # lilo(8) completion
  5415. #
  5416. have lilo && {
  5417. _lilo_labels()
  5418. {
  5419.     COMPREPLY=( $( awk -F'=' '/label/ {print $2}' \
  5420.         /etc/lilo.conf | sed -e 's/"//g' | grep "^$cur" ) )
  5421. }
  5422.  
  5423. _lilo()
  5424. {
  5425.     local cur prev
  5426.  
  5427.     COMPREPLY=()
  5428.     cur=`_get_cword`
  5429.     prev=${COMP_WORDS[COMP_CWORD-1]}
  5430.  
  5431.     case $prev in
  5432.         -@(C|i|m|s|S))
  5433.             _filedir
  5434.             return 0
  5435.             ;;
  5436.         -r)
  5437.             _filedir -d
  5438.             return 0
  5439.             ;;
  5440.         -@(I|D|R))
  5441.             # label completion
  5442.             _lilo_labels
  5443.             return 0
  5444.             ;;
  5445.         -@(A|b|M|u|U))
  5446.             # device completion
  5447.             cur=${cur:=/dev/}
  5448.             _filedir
  5449.             return 0
  5450.             ;;
  5451.         -T)
  5452.             # topic completion
  5453.             COMPREPLY=( $( compgen -W 'help ChRul EBDA geom geom= \
  5454.                     table= video' -- $cur ) )
  5455.             return 0
  5456.             ;;
  5457.     esac
  5458.  
  5459.     if [[ "$cur" == -* ]]; then
  5460.         # relevant options completion
  5461.         COMPREPLY=( $( compgen -W '-A -b -c -C -d -f -g -i -I -l -L -m \
  5462.             -M -p -P -q -r -R -s -S -t -T -u -U -v -V -w -x -z' -- \
  5463.             $cur ) )
  5464.     fi
  5465. }
  5466. complete -F _lilo lilo
  5467. }
  5468.  
  5469. # links completion
  5470. #
  5471. have links &&
  5472. _links()
  5473. {
  5474.     local cur
  5475.   
  5476.     COMPREPLY=()
  5477.     cur=`_get_cword`
  5478.   
  5479.     case "$cur" in
  5480.         --*)
  5481.         COMPREPLY=( $( compgen -W '--help' -- $cur ) )
  5482.         ;;
  5483.         -*)
  5484.         COMPREPLY=( $( compgen -W '-async-dns -max-connections \
  5485.                 -max-connections-to-host -retries \
  5486.                 -receive-timeout -unrestartable-receive-timeout\
  5487.                 -format-cache-size -memory-cache-size \
  5488.                 -http-proxy -ftp-proxy -download-dir \
  5489.                 -assume-codepage -anonymous -dump -no-connect \
  5490.                 -source -version -help' -- $cur ) )
  5491.         ;;
  5492.         *)
  5493.         if [ -r ~/.links/links.his ]; then
  5494.             COMPREPLY=( $( compgen -W '$( < ~/.links/links.his )' \
  5495.                    -- $cur ) )
  5496.         fi
  5497.                 _filedir '@(htm|html)'
  5498.                 return 0
  5499.         ;;
  5500.     esac
  5501.   
  5502.     return 0
  5503. } &&
  5504. complete -F _links $filenames links
  5505.  
  5506. [ $UNAME = FreeBSD ] && {
  5507. # FreeBSD package management tool completion
  5508. #
  5509. _pkg_delete()
  5510. {
  5511.     local cur pkgdir prev
  5512.  
  5513.     pkgdir=${PKG_DBDIR:-/var/db/pkg}/
  5514.     cur=`_get_cword`
  5515.     prev=${COMP_WORDS[COMP_CWORD-1]}
  5516.  
  5517.     [ "$prev" = "-o" -o "$prev" = "-p" -o "$prev" = "-W" ] && return 0
  5518.  
  5519.     COMPREPLY=( $( compgen -d $pkgdir$cur ) )
  5520.     COMPREPLY=( ${COMPREPLY[@]#$pkgdir} )
  5521.  
  5522.     return 0
  5523. }
  5524. complete -F _pkg_delete $dirnames pkg_delete pkg_info
  5525. have pkg_deinstall && complete -F _pkg_delete $dirnames pkg_deinstall
  5526.  
  5527. # FreeBSD kernel module commands
  5528. #
  5529. _kldload()
  5530. {
  5531.     local cur moddir
  5532.  
  5533.     moddir=/modules/
  5534.     [ -d $moddir ] || moddir=/boot/kernel/
  5535.     cur=`_get_cword`
  5536.  
  5537.     COMPREPLY=( $( compgen -f $moddir$cur ) )
  5538.     COMPREPLY=( ${COMPREPLY[@]#$moddir} )
  5539.     COMPREPLY=( ${COMPREPLY[@]%.ko} )
  5540.  
  5541.     return 0
  5542. }
  5543. complete -F _kldload $filenames kldload
  5544.  
  5545. _kldunload()
  5546. {
  5547.     local cur
  5548.     cur=`_get_cword`
  5549.     COMPREPLY=( $(kldstat | sed -ne "s/^.*[ \t]\+\($cur[a-z_]\+\).ko$/\1/p") )
  5550. }
  5551. complete -F _kldunload $filenames kldunload
  5552. }
  5553.  
  5554. # FreeBSD portupgrade completion
  5555. #
  5556. have portupgrade &&
  5557. _portupgrade()
  5558. {
  5559.     local cur pkgdir prev
  5560.  
  5561.     pkgdir=${PKG_DBDIR:-/var/db/pkg}/
  5562.     cur=`_get_cword`
  5563.     prev=${COMP_WORDS[COMP_CWORD-1]}
  5564.  
  5565.     [ "$prev" = "-l" -o "$prev" = "-L" -o "$prev" = "-o" ] && return 0
  5566.  
  5567.     COMPREPLY=( $( compgen -d $pkgdir$cur ) )
  5568.     COMPREPLY=( ${COMPREPLY[@]#$pkgdir} )
  5569.     COMPREPLY=( ${COMPREPLY[@]%-*} )
  5570.  
  5571.     return 0
  5572. } &&
  5573. complete -F _portupgrade $dirnames portupgrade
  5574.  
  5575. # FreeBSD portinstall completion
  5576. #
  5577. have portinstall &&
  5578. _portinstall()
  5579. {
  5580.     local cur portsdir prev indexfile
  5581.     local -a COMPREPLY2
  5582.  
  5583.     portsdir=${PORTSDIR:-/usr/ports}/
  5584.     cur=`_get_cword`
  5585.     prev=${COMP_WORDS[COMP_CWORD-1]}
  5586.     # First try INDEX-5
  5587.     indexfile=$portsdir/INDEX-5
  5588.     # Then INDEX if INDEX-5 does not exist or system is not FreeBSD 5.x
  5589.     [ "${OSTYPE%.*}" = "freebsd5" -a -f $indexfile ] ||
  5590.       indexfile=$portsdir/INDEX
  5591.  
  5592.     [ "$prev" = "-l" -o "$prev" = "-L" -o "$prev" = "-o" ] && return 0
  5593.  
  5594.     COMPREPLY=( $( egrep "^$cur" < $indexfile | cut -d'|' -f1 ) )
  5595.     COMPREPLY2=( $( egrep "^[^\|]+\|$portsdir$cur" < $indexfile | \
  5596.             cut -d'|' -f2 ) )
  5597.     COMPREPLY2=( ${COMPREPLY2[@]#$portsdir} )
  5598.     COMPREPLY=( "${COMPREPLY[@]}" "${COMPREPLY2[@]}" )
  5599.  
  5600.     return 0
  5601. } &&
  5602. complete -F _portinstall $dirnames portinstall
  5603.  
  5604. # Slackware Linux removepkg completion
  5605. #
  5606. have removepkg && [ -f /etc/slackware-version ] &&
  5607. _removepkg()
  5608. {
  5609.     local packages cur
  5610.  
  5611.     COMPREPLY=()
  5612.     cur=`_get_cword`
  5613.  
  5614.     COMPREPLY=( $( (cd /var/log/packages; compgen -f -- "$cur") ) )
  5615. } &&
  5616. complete -F _removepkg $filenames removepkg &&
  5617.     complete $dirnames -f -X '!*.tgz' installpkg upgradepkg explodepkg
  5618.  
  5619. # look(1) completion
  5620. #
  5621. have look && 
  5622. _look()
  5623. {
  5624.     local cur
  5625.   
  5626.     COMPREPLY=()
  5627.     cur=`_get_cword`
  5628.  
  5629.     if [ $COMP_CWORD = 1 ]; then
  5630.         COMPREPLY=( $( compgen -W '$(look $cur)' ) )
  5631.     fi
  5632. } &&
  5633. complete -F _look $default look
  5634.  
  5635. # ypcat(1) and ypmatch(1) completion
  5636. #
  5637. have ypmatch &&
  5638. _ypmatch()
  5639. {
  5640.     local cur map
  5641.  
  5642.     COMPREPLY=()
  5643.     cur=`_get_cword`
  5644.  
  5645.     [ $1 = ypcat ] && [ $COMP_CWORD -gt 1 ] && return 0
  5646.     [ $1 = ypmatch ] && [ $COMP_CWORD -gt 2 ] && return 0
  5647.  
  5648.     if [ $1 = ypmatch ] && [ $COMP_CWORD -eq 1 ] && \
  5649.        [ ${#COMP_WORDS[@]} -eq 3 ]; then
  5650.         map=${COMP_WORDS[2]}
  5651.         COMPREPLY=( $( compgen -W '$( ypcat $map | \
  5652.                         cut -d':' -f 1 )' -- $cur) )
  5653.     else
  5654.         [ $1 = ypmatch ] && [ $COMP_CWORD -ne 2 ] && return 0
  5655.         COMPREPLY=( $( compgen -W \
  5656.                   '$( echo $(ypcat -x | cut -d"\"" -f 2))' -- $cur))
  5657.     fi
  5658.  
  5659.     return 0
  5660. } &&
  5661. complete -F _ypmatch ypmatch ypcat
  5662.  
  5663. # mplayer(1) completion
  5664. #
  5665. have mplayer && {
  5666. _mplayer_options_list()
  5667. {
  5668.     cur=${cur%\\}
  5669.     COMPREPLY=( $( $1 $2 help 2> /dev/null | \
  5670.         sed -e '1,/^Available/d' | awk '{print $1}' | \
  5671.         sed -e 's/:$//' -e 's/^'${2#-}'$//' -e 's/<.*//' | \
  5672.         grep "^$cur" ) )
  5673. }
  5674.  
  5675. _mplayer()
  5676. {
  5677.     local cmd cur prev skinsdir IFS=$' \t\n' i j k=0
  5678.  
  5679.     COMPREPLY=()
  5680.     cmd=${COMP_WORDS[0]}
  5681.     cur=`_get_cword`
  5682.     prev=${COMP_WORDS[COMP_CWORD-1]}
  5683.  
  5684.     case "$prev" in
  5685.         -@(ac|afm|vc|vfm|ao|vo|vop|fstype))
  5686.             _mplayer_options_list mplayer $prev
  5687.             return 0
  5688.             ;;
  5689.         -@(oac|ovc|of))
  5690.             _mplayer_options_list mencoder $prev
  5691.             return 0
  5692.             ;;
  5693.         -audiofile)
  5694.             _filedir '@(mp3|MP3|mpg|MPG|ogg|OGG|wav|WAV|mid|MID|flac|FLAC|mka|MKA)'
  5695.             return 0
  5696.             ;;
  5697.         -font)
  5698.             _filedir '@(desc|ttf)'
  5699.             return 0
  5700.             ;;
  5701.         -sub)
  5702.             _filedir '@(srt|SRT|sub|SUB|txt|TXT|utf|UTF|rar|RAR|mpsub|smi|js|ssa|SSA|aas|AAS)'
  5703.             return 0
  5704.             ;;
  5705.         -vobsub)
  5706.             _filedir '@(idx|IDX|ifo|IFO|sub|SUB)'
  5707.             IFS=$'\t\n' 
  5708.             COMPREPLY=( $( for i in "${COMPREPLY[@]}"; do
  5709.                         if [ -f $i -a -r $i ]; then
  5710.                             echo ${i%.*}
  5711.                         else
  5712.                             echo $i
  5713.                         fi
  5714.                        done ) )
  5715.             IFS=$' \t\n' 
  5716.             return 0
  5717.             ;;
  5718.         -ifo)
  5719.             _filedir '@(ifo|IFO)'
  5720.             return 0
  5721.             ;;
  5722.         -cuefile)
  5723.             _filedir '@(bin|BIN|cue|CUE)'
  5724.             return 0
  5725.             ;;
  5726.         -skin)
  5727.             # if you don't have installed mplayer in /usr/local you
  5728.             # may want to set the MPLAYER_SKINS_DIR global variable
  5729.             if [ -n "$MPLAYER_SKINS_DIR" ]; then
  5730.                 skinsdir=$MPLAYER_SKINS_DIR
  5731.             else
  5732.                 skinsdir=/usr/local/share/mplayer/Skin
  5733.             fi
  5734.  
  5735.             IFS=$'\t\n' 
  5736.             for i in ~/.mplayer/Skin $skinsdir; do
  5737.                 if [ -d $i -a -r $i ]; then
  5738.                     for j in $( compgen -d $i/$cur ); do
  5739.                         COMPREPLY[$k]=${j#$i/}
  5740.                         k=$((++k))
  5741.                     done
  5742.                 fi
  5743.             done
  5744.             IFS=$' \t\n' 
  5745.             return 0
  5746.             ;;
  5747.         -@(mixer|@(cdrom|dvd)-device|dvdauth|fb|zrdev))
  5748.             cur=${cur:=/dev/}
  5749.             _filedir
  5750.             return 0
  5751.             ;;
  5752.         -@(edl?(out)|lircconf|menu-cfg|playlist|csslib|dumpfile)| \
  5753.         -@(subfile|vobsub|aofile|fbmodeconfig|include|o|dvdkey)| \
  5754.         -passlogfile)
  5755.             _filedir
  5756.             return 0
  5757.             ;;
  5758.         -@(auto@(q|sync)|loop|menu-root|speed|sstep|aid|alang)| \
  5759.         -@(?(@(audio|sub)-)demuxer|bandwidth|cache|chapter)| \
  5760.         -@(dvd?(angle)|fps|frames|mc|passwd|user|sb|srate|ss|vcd)| \
  5761.         -@(vi?(d|vo)|ffactor|sid|slang|spu@(align|aa|gauss))| \
  5762.         -@(vobsubid|delay|bpp|brightness|contrast|dfbopts|display)| \
  5763.         -@(fbmode|geometry|guiwid|hue|icelayer|screen[wh]|wid)| \
  5764.         -@(monitor@(aspect|-@(dotclock|[hv]freq))|panscan|saturation)| \
  5765.         -@(xineramascreen|zr@(crop|norm|quality|[xy]doff|[vh]dec))| \
  5766.         -@(aspect|pp|x|y|xy|z|stereo|audio-@(density|delay|preload))| \
  5767.         -@(endpos|osdlevel|ffourcc|sws|channels|skiplimit|format)| \
  5768.         -@(ofps|aa@(driver|@(osd|sub)color)|vobsubout?(i@(ndex|d)))| \
  5769.         -sub@(-bg-@(alpha|color)|cp|delay|fps|pos|align|width)| \
  5770.         -sub@(font-@(blur|outline|autoscale|encoding|@(osd|text)-scale)))
  5771.             return 0
  5772.             ;;
  5773.         -lavdopts)
  5774.             COMPREPLY=( $( compgen -W 'ec er= bug= idct= gray' \
  5775.                     -- $cur ) )
  5776.             return 0
  5777.             ;;
  5778.         -lavcopts)
  5779.             COMPREPLY=( $( compgen -W 'vcodec= vqmin= vqscale= \
  5780.                     vqmax= mbqmin= mbqmax= vqdiff= \
  5781.                     vmax_b_frames= vme= vhq v4mv \
  5782.                     keyint= vb_strategy= vpass= \
  5783.                     aspect= vbitrate= vratetol= \
  5784.                     vrc_maxrate= vrc_minrate= \
  5785.                     vrc_buf_size= vb_qfactor= vi_qfactor= \
  5786.                     vb_qoffset= vi_qoffset= vqblur= \
  5787.                     vqcomp= vrc_eq= vrc_override= \
  5788.                     vrc_init_cplx= vqsquish= vlelim= \
  5789.                     vcelim= vstrict= vdpart vpsize= gray \
  5790.                     vfdct= idct= lumi_mask= dark_mask= \
  5791.                     tcplx_mask= scplx_mask= naq ildct \
  5792.                     format= pred qpel precmp= cmp= \
  5793.                     subcmp= predia= dia= trell last_pred= \
  5794.                     preme= subq= psnr mpeg_quant aic umv' \
  5795.                     -- $cur ) )
  5796.             return 0
  5797.             ;;
  5798.         -ssf)
  5799.             COMPREPLY=( $( compgen -W 'lgb= cgb= ls= cs= chs= \
  5800.                     cvs=' -- $cur ) )
  5801.             return 0
  5802.             ;;
  5803.         -jpeg)
  5804.             COMPREPLY=( $( compgen -W 'noprogressive progressive \
  5805.                     nobaseline baseline optimize= \
  5806.                     smooth= quality= outdir=' -- $cur ) )
  5807.             return 0
  5808.             ;;
  5809.         -xvidopts)
  5810.             COMPREPLY=( $( compgen -W 'dr2 nodr2' -- $cur ) )
  5811.             return 0
  5812.             ;;
  5813.         -xvidencopts)
  5814.             COMPREPLY=( $( compgen -W 'pass= bitrate= \
  5815.                     fixed_quant= me_quality= 4mv \
  5816.                     rc_reaction_delay_factor= \
  5817.                     rc_averaging_period= rc_buffer= \
  5818.                     quant_range= min_key_interval= \
  5819.                     max_key_interval= mpeg_quant \
  5820.                     mod_quant lumi_mask hintedme \
  5821.                     hintfile debug keyframe_boost= \
  5822.                     kfthreshold= kfreduction=' -- $cur ) )
  5823.             return 0
  5824.             ;;
  5825.         -divx4opts)
  5826.             COMPREPLY=( $( compgen -W 'br= key= deinterlace q= \
  5827.                     min_quant= max_quant= rc_period= \
  5828.                     rc_reaction_period= crispness= \
  5829.                     rc_reaction_ratio= pass= vbrpass= \
  5830.                     help' -- $cur ) )
  5831.             return 0
  5832.             ;;
  5833.         -info)
  5834.             COMPREPLY=( $( compgen -W 'name= artist= genre= \
  5835.                     subject= copyright= srcform= \
  5836.                     comment= help' -- $cur ) )
  5837.             return 0
  5838.             ;;
  5839.         -lameopts)
  5840.             COMPREPLY=( $( compgen -W 'vbr= abr cbr br= q= aq= \
  5841.                     ratio= vol= mode= padding= fast \
  5842.                     preset= help' -- $cur ) )
  5843.             return 0
  5844.             ;;
  5845.         -rawaudio)
  5846.             COMPREPLY=( $( compgen -W 'on channels= rate= \
  5847.                     samplesize= format=' -- $cur ) )
  5848.             return 0
  5849.             ;;
  5850.         -rawvideo)
  5851.             COMPREPLY=( $( compgen -W 'on fps= sqcif qcif cif \
  5852.                     4cif pal ntsc w= h= y420 yv12 yuy2 \
  5853.                     y8 format= size=' -- $cur ) )
  5854.             return 0
  5855.             ;;
  5856.         -aop)
  5857.             COMPREPLY=( $( compgen -W 'list= delay= format= fout= \
  5858.                     volume= mul= softclip' -- $cur ) )
  5859.             return 0
  5860.             ;;
  5861.         -dxr2)
  5862.             COMPREPLY=( $( compgen -W 'ar-mode= iec958-encoded \
  5863.                     iec958-decoded mute ucode= 75ire bw \
  5864.                     color interlaced macrovision= norm= \
  5865.                     square-pixel ccir601-pixel cr-left= \
  5866.                     cr-right= cr-top= cr-bot= ck-rmin= \
  5867.                     ck-gmin= ck-bmin= ck-rmax= ck-gmax= \
  5868.                     ck-bmax= ck-r= ck-g= ck-b= \
  5869.                     ignore-cache= ol-osd= olh-cor= \
  5870.                     olw-cor= olx-cor= oly-cor= overlay \
  5871.                     overlay-ratio= update-cache' -- $cur ))
  5872.             return 0
  5873.             ;;
  5874.         -tv)
  5875.             COMPREPLY=( $( compgen -W 'on noaudio driver= device= \
  5876.                     input= freq= outfmt= width= height= \
  5877.                     buffersize= norm= channel= chanlist= \
  5878.                     audiorate= forceaudio alsa amode= \
  5879.                     forcechan= adevice= audioid= volume= \
  5880.                     bass= treble= balance= fps= \
  5881.                     channels= immediatemode=' -- $cur ) )
  5882.             return 0
  5883.             ;;
  5884.         -mf)
  5885.             COMPREPLY=( $( compgen -W 'on w= h= fps= type=' \
  5886.                     -- $cur ) )
  5887.             return 0
  5888.             ;;
  5889.         -cdda)
  5890.             COMPREPLY=( $( compgen -W 'speed= paranoia= \
  5891.                     generic-dev= sector-size= overlap= \
  5892.                     toc-bias toc-offset= skip noskip' \
  5893.                     -- $cur ) )
  5894.             return 0
  5895.             ;;
  5896.         -input)
  5897.             COMPREPLY=( $( compgen -W 'conf= ar-delay ar-rate \
  5898.                     keylist cmdlist js-dev file' -- $cur ) )
  5899.             return 0
  5900.             ;;
  5901.         -af)
  5902.             COMPREPLY=( $( compgen -W 'resample resample= \
  5903.                     channels channels= format format= \
  5904.                     volume volume= delay delay= pan \
  5905.                     pan= sub sub= surround surround=' \
  5906.                     -- $cur ) )
  5907.             return 0
  5908.             ;;
  5909.         -af-adv)
  5910.             COMPREPLY=( $( compgen -W 'force= list=' -- $cur ) )
  5911.             return 0
  5912.             ;;
  5913.     esac
  5914.  
  5915.     case "$cur" in
  5916.         -*)
  5917.             COMPREPLY=( $( compgen -W '-aid -alang -audio-demuxer \
  5918.                     -audiofile -cdrom-device -cache -cdda \
  5919.                     -channels -chapter -csslib -demuxer \
  5920.                     -dvd -dvd-device -dvdangle -dvdauth \
  5921.                     -dvdkey -dvdnav -forceidx -fps -frames \
  5922.                     -hr-mp3-seek -idx -mc -mf -ni -nobps \
  5923.                     -passwd -rawaudio -rtsp-stream-over-tcp\
  5924.                     -skipopening -sb -srate -ss -tv -user \
  5925.                     -vcd -vid -vivo -ifo -ffactor -font \
  5926.                     -noautosub -nooverlapsub -sid -slang \
  5927.                     -sub -subcc -subcp -sub-demuxer \
  5928.                     -subdelay -subfont-autoscale \
  5929.                     -subfont-blur -subfont-encoding \
  5930.                     -subfont-osd-scale -subfont-outline \
  5931.                     -subfont-text-scale -subfps -subfile \
  5932.                     -subpos -unicode -utf8 -vobsub \
  5933.                     -vobsubid -ac -afm -aspect -flip \
  5934.                     -lavdopts -noaspect -nosound -pp -ssf \
  5935.                     -stereo -sws -vc -vfm -vop -xvidopts\
  5936.                     -xy -zoom -bandwidth -cuefile \
  5937.                     -noextbased -rawvideo -overlapsub \
  5938.                     -sub-bg-alpha -sub-bg-color -subalign \
  5939.                     -subwidth -sub-no-text-pp -spualign \
  5940.                     -spuaa -spugauss -pphelp -verbose -v \
  5941.                     -noni -noidx -nohr-mp3-seek -extbased \
  5942.                     -bps -oldpp -nozoom -noflip -nounicode \
  5943.                     -noutf8' -- $cur ) )
  5944.             # add mplayer specific options
  5945.             [[ "$cmd" == @(?(g)mplayer) ]] && COMPREPLY=( "${COMPREPLY[@]}" \
  5946.                 $(compgen -W '-autoq -autosync -benchmark \
  5947.                     -framedrop -h -help -hardframedrop \
  5948.                     -identify -input -lircconf -loop \
  5949.                     -nojoystick -nolirc -nortc -playlist \
  5950.                     -quiet -really-quiet -rnd -sdp -skin \
  5951.                     -slave -softsleep -speed -sstep \
  5952.                     -use-stdin -dumpaudio -dumpfile \
  5953.                     -dumpstream -dumpvideo -dumpmicrodvdsub\
  5954.                     -dumpmpsub -dumpsrtsub -dumpjacosub \
  5955.                     -dumpsami -dumpsub -osdlevel -af \
  5956.                     -af-adv -ao -aofile -aop -delay -mixer \
  5957.                     -nowaveheader -bpp -brightness \
  5958.                     -contrast -display -double -dr -dxr2 \
  5959.                     -fb -fbmode -fbmodeconfig -forcexv -fs \
  5960.                     -geometry -hue -icelayer -jpeg \
  5961.                     -monitor-dotclock -monitor-hfreq \
  5962.                     -monitor-vfreq -monitoraspect \
  5963.                     -nograbpointer -noslices -panscan \
  5964.                     -rootwin -saturation -screenw -screenh \
  5965.                     -stop-xscreensaver -vm -vo -vsync -wid \
  5966.                     -xineramascreen -z -zrbw -zrcrop \
  5967.                     -zrdev -zrfd -zrhelp -zrnorm -zrquality \
  5968.                     -zrvdec -zrhdec -zrxdoff -zrydoff -y \
  5969.                     -edl -edlout -enqueue -fixed-vo \
  5970.                     -menu -menu-root -menu-cfg -shuffle \
  5971.                     -format -aahelp -dfbopts -fstype \
  5972.                     -guiwid -nokeepaspect -x --help \
  5973.                     -aaosdcolor -aasubcolor -aadriver \
  5974.                     -aaextended -aaeight' -- $cur) )
  5975.             # add mencoder specific options
  5976.             [[ "$cmd" = mencoder ]] && COMPREPLY=( "${COMPREPLY[@]}" \
  5977.                 $(compgen -W '-audio-density -audio-delay \
  5978.                     -audio-preload -divx4opts -endpos \
  5979.                     -ffourcc -include -info -lameopts \
  5980.                     -lavcopts -noskip -o -oac -ofps -ovc \
  5981.                     -passlogfile -skiplimit -vobsubout \
  5982.                     -vobsuboutindex -vobsuboutid \
  5983.                     -xvidencopts -of --verbose' -- $cur) )
  5984.             ;;
  5985.         *)
  5986.             _filedir '@(mp?(e)g|MP?(E)G|wm[av]|WM[AV]|avi|AVI|asf|ASF|vob|VOB|bin|BIN|dat|DAT|vcd|VCD|ps|PS|pes|PES|fli|FLI|flv|FLV|viv|VIV|rm?(j)|RM?(J)|ra?(m)|RA?(M)|yuv|YUV|mov|MOV|qt|QT|mp[34]|MP[34]|m4v|M4V|og[gm]|OG[GM]|wav|WAV|dump|DUMP|mk[av]|MK[AV]|m4a|M4A|aac|AAC|m2v|M2V|dv|DV|rmvb|RMVB|mid|MID|ts|TS|3gp|mpc|MPC|flac|FLAC|flv|FLV|divx|DIVX)'
  5987.             ;;
  5988.     esac
  5989.  
  5990.     return 0
  5991. }
  5992. complete $filenames -F _mplayer mplayer mencoder gmplayer kplayer
  5993. }
  5994.  
  5995. # KDE dcop completion
  5996. #
  5997. have dcop &&
  5998. _dcop()
  5999. {
  6000.     local cur compstr
  6001.  
  6002.     COMPREPLY=()
  6003.     cur=`_get_cword`
  6004.     if [ -z $cur ]; then
  6005.         compstr=${COMP_WORDS[*]}
  6006.     else
  6007.         compstr=$( command echo ${COMP_WORDS[*]} | sed "s/ $cur$//" )
  6008.     fi
  6009.     COMPREPLY=( $( compgen -W '$( command $compstr | sed s/\(.*\)// )'  -- $cur ) )
  6010. } &&
  6011. complete -F _dcop dcop
  6012.  
  6013. # wvdial(1) completion
  6014. #
  6015. have wvdial &&
  6016. _wvdial()
  6017. {
  6018.     local cur prev config i IFS=$'\t\n'
  6019.  
  6020.     COMPREPLY=()
  6021.     cur=`_get_cword`
  6022.     prev=${COMP_WORDS[COMP_CWORD-1]}
  6023.  
  6024.     case $prev in
  6025.         --config)
  6026.             _filedir
  6027.             return 0
  6028.             ;;
  6029.     esac
  6030.  
  6031.     case $cur in
  6032.         -*)
  6033.             COMPREPLY=( $( compgen -W '--config --chat \
  6034.                 --remotename --help --version --no-syslog' \
  6035.                 -- $cur ) )
  6036.             ;;
  6037.         *)
  6038.             # start with global and personal config files
  6039.                    config="/etc/wvdial.conf"$'\t'"$HOME/.wvdialrc"
  6040.             # replace with command line config file if present
  6041.             for (( i=1; i < COMP_CWORD; i++ )); do
  6042.                 if [[ "${COMP_WORDS[i]}" == "--config" ]]; then
  6043.                     config=${COMP_WORDS[i+1]}
  6044.                     break
  6045.                 fi
  6046.             done
  6047.             # parse config files for sections and
  6048.             # remove default section
  6049.             COMPREPLY=( $( sed -ne \
  6050.                     "s|^\[Dialer \($cur.*\)\]$|\1|p" \
  6051.                     $config 2>/dev/null |grep -v '^Defaults$'))
  6052.             # escape spaces
  6053.             COMPREPLY=${COMPREPLY// /\\ }
  6054.             ;;
  6055.     esac
  6056.  
  6057. } &&
  6058. complete -F _wvdial wvdial
  6059.  
  6060. # gpg(1) completion
  6061. #
  6062. have gpg &&
  6063. _gpg() 
  6064. {
  6065.     local cur prev
  6066.  
  6067.     COMPREPLY=()
  6068.     cur=`_get_cword`
  6069.     prev=${COMP_WORDS[COMP_CWORD-1]}
  6070.  
  6071.     case "$prev" in
  6072.     -@(s|-sign|-clearsign|-decrypt-files|-load-extension)) 
  6073.         _filedir
  6074.         return 0
  6075.         ;;
  6076.     --@(export|@(?(l|nr|nrl)sign|edit)-key)) 
  6077.         # return list of public keys
  6078.         COMPREPLY=( $( compgen -W "$( gpg --list-keys 2>/dev/null | sed -ne 's@^pub.*/\([^ ]*\).*\(<\([^>]*\)>\).*$@\1 \3@p')" -- "$cur" ))
  6079.         return 0
  6080.         ;;
  6081.     -@(r|-recipient))
  6082.         COMPREPLY=( $( compgen -W "$( gpg --list-keys 2>/dev/null | sed -ne 's@^pub.*<\([^>]*\)>.*$@\1@p')" -- "$cur" ))
  6083.         if [ -e ~/.gnupg/gpg.conf ]; then
  6084.             COMPREPLY=( "${COMPREPLY[@]}" $( compgen -W "$( sed -ne 's@^[ \t]*group[ \t][ \t]*\([^=]*\).*$@\1@p' ~/.gnupg/gpg.conf  )" -- "$cur") )
  6085.         fi
  6086.         return 0
  6087.         ;;
  6088.     esac
  6089.  
  6090.     if [[ "$cur" == -* ]]; then
  6091.         COMPREPLY=( $( compgen -W '-s -b -e -f -c -d -a -r -u -Z -o -v\
  6092.                 -q -n -N $(gpg --dump-options)' -- $cur ) )
  6093.      fi
  6094.  
  6095. } &&
  6096. complete -F _gpg $default gpg
  6097.  
  6098. # iconv(1) completion
  6099. #
  6100. have iconv &&
  6101. _iconv()
  6102. {
  6103.     local cur prev
  6104.  
  6105.     COMPREPLY=()
  6106.     cur=`_get_cword`
  6107.     prev=${COMP_WORDS[COMP_CWORD-1]}
  6108.  
  6109.     case "$prev" in
  6110.         -@(f|t|-@(from|to)-code))
  6111.             COMPREPLY=( $( compgen -W \
  6112.                 '$( iconv --list | sed -e "s@//@@;" )' -- "$cur" ) )
  6113.             return 0
  6114.             ;;
  6115.     esac
  6116.  
  6117.  
  6118.     if [[ "$cur" = -* ]]; then
  6119.         COMPREPLY=( $( compgen -W '--from-code -f --to-code -t --list
  6120.         --output -o --verbose' -- "$cur" ) )
  6121.         return 0
  6122.     fi
  6123. } &&
  6124. complete -F _iconv $default iconv
  6125.  
  6126. # dict(1) completion
  6127. #
  6128. { have dict || have rdict; } && {
  6129. _dictdata()
  6130. {
  6131.     dict $host $port $1 2>/dev/null | sed -ne \
  6132.         's/^['$'\t '']['$'\t '']*\([^'$'\t '']*\).*$/\1/p'
  6133. }
  6134.  
  6135. _dict()
  6136. {
  6137.     local cur prev host port db dictfile
  6138.  
  6139.     COMPREPLY=()
  6140.     cur=`_get_cword`
  6141.     prev=${COMP_WORDS[COMP_CWORD-1]}
  6142.     dictfile=/usr/share/dict/words
  6143.  
  6144.     for (( i=1; i < COMP_CWORD; i++ )); do
  6145.         case "${COMP_WORDS[i]}" in
  6146.         -@(h|--host))
  6147.             host=${COMP_WORDS[i+1]}
  6148.             [ -n "$host" ] && host="-h $host"
  6149.             i=$((++i))
  6150.             ;;
  6151.         -@(p|-port))
  6152.             port=${COMP_WORDS[i+1]}
  6153.             [ -n "$port" ] && port="-p $port"
  6154.             i=$((++i))
  6155.             ;;
  6156.         -@(d|-database))
  6157.             db=${COMP_WORDS[i+1]}
  6158.             [ -n "$db" ] && host="-d $db"
  6159.             i=$((++i))
  6160.             ;;
  6161.         *)
  6162.             ;;
  6163.         esac
  6164.     done
  6165.  
  6166.     if [[ "$cur" = -* ]]; then
  6167.         COMPREPLY=( $( compgen -W '-h --host -p --port -d --database \
  6168.                    -m --match -s --strategy -c --config -C \
  6169.                    --nocorrect -D --dbs -S --strats -H \
  6170.                    --serverhelp -i --info -I --serverinfo \
  6171.                    -a --noauth -u --user -k --key -V --version \
  6172.                    -L --license --help -v --verbose -r --raw \
  6173.                    -P --pager --debug --html --pipesize --client' \
  6174.                    -- "$cur" ) )
  6175.         return 0
  6176.     fi
  6177.  
  6178.     case "$prev" in
  6179.     -@(d|-database|i|info))
  6180.         COMPREPLY=( $( compgen -W '$( _dictdata -D )' -- "$cur" ) )
  6181.         return 0
  6182.         ;;
  6183.     -@(s|-strategy))
  6184.         COMPREPLY=( $( compgen -W '$( _dictdata -S )' -- "$cur" ) )
  6185.         return 0
  6186.         ;;
  6187.     *)
  6188.         ;;
  6189.     esac
  6190.  
  6191.     [ -r $dictfile ] && \
  6192.         COMPREPLY=( $( compgen -W '$( cat $dictfile )' -- "$cur" ) )
  6193. }
  6194. complete -F _dict $default dict rdict
  6195. }
  6196.  
  6197. # cdrecord(1) completion
  6198. #
  6199. have cdrecord &&
  6200. _cdrecord()
  6201. {
  6202.     local cur prev i generic_options track_options track_mode
  6203.  
  6204.     COMPREPLY=()
  6205.     cur=`_get_cword`
  6206.     prev=${COMP_WORDS[COMP_CWORD-1]}
  6207.  
  6208.     # foo=bar style option
  6209.     if [[ "$cur" == *=* ]]; then
  6210.         prev=${cur/=*/}
  6211.         cur=${cur/*=/}
  6212.         case "$prev" in
  6213.             @(text|cue)file)
  6214.                 _filedir
  6215.                 return 0
  6216.                 ;;
  6217.             blank)
  6218.                 COMPREPLY=( $( compgen -W 'help all fast \
  6219.                 track unreserve trtail unclose session' \
  6220.                 -- $cur ) )
  6221.                 return 0
  6222.                 ;;
  6223.             driveropts)
  6224.                 COMPREPLY=( $( compgen -W 'burnfree noburnfree\
  6225.                   varirec= audiomaster forcespeed noforcespeed\
  6226.                   speedread nospeedread singlesession \
  6227.                   nosinglesession hidecdr nohidecdr tattooinfo\
  6228.                   tattoofile=' -- $cur ) )
  6229.                 return 0
  6230.                 ;;
  6231.         esac
  6232.     fi
  6233.  
  6234.     generic_options=(-version -v -V -d -silent -s -force -immed -dummy \
  6235.              -dao -raw -raw96r -raw96p -raw16 -multi -msinfo -toc \
  6236.              -atip -fix -nofix -waiti -load -lock -eject -format \
  6237.              -setdropts -checkdrive -prcap -inq -scanbus -reset \
  6238.              -abort -overburn -ignsize -useinfo -packet -noclose \
  6239.              -text debug= kdebug= kd= minbuf= speed= blank= fs= \
  6240.              dev= gracetime= timeout= driver= driveropts= \
  6241.              defpregap= pktsize= mcn= textfile= cuefile=)
  6242.     track_options=(-audio -swab -data -mode2 -xa -xa1 -xa2 -xamix -cdi \
  6243.                -isosize -pad padsize= -nopad -shorttrack -noshorttrack\
  6244.                pregap= -preemp -nopreemp -copy -nocopy -scms tcsize= \
  6245.                isrc= index=)
  6246.     # look if previous was either a file or a track option
  6247.     track_mode=0
  6248.     if [ $COMP_CWORD -gt 1 ]; then
  6249.         if [ -f "$prev" ]; then
  6250.             track_mode=1
  6251.         else
  6252.             for (( i=0; i < ${#track_options[@]}; i++ )); do
  6253.                 if [[ "${track_options[i]}" == "$prev" ]]; then
  6254.                     track_mode=1
  6255.                     break
  6256.                 fi
  6257.             done
  6258.         fi
  6259.     fi
  6260.  
  6261.     # files are always eligible completion
  6262.     _filedir
  6263.     # track options are always available
  6264.     COMPREPLY=( "${COMPREPLY[@]}" $( compgen -W '${track_options[@]}' -- $cur ) )
  6265.     # general options are no more available after file or track option
  6266.     if [ $track_mode -eq 0 ]; then
  6267.         COMPREPLY=( "${COMPREPLY[@]}" \
  6268.                 $( compgen -W '${generic_options[@]}' -- $cur ) )
  6269.     fi
  6270.  
  6271. } &&
  6272. complete -F _cdrecord $filenames cdrecord
  6273.  
  6274. # mkisofs(8) completion
  6275. #
  6276. have mkisofs &&
  6277. _mkisofs()
  6278. {
  6279.     local cur prev
  6280.  
  6281.     COMPREPLY=()
  6282.     cur=`_get_cword`
  6283.     prev=${COMP_WORDS[COMP_CWORD-1]}
  6284.  
  6285.     case "$prev" in
  6286.         -@(o|abstract|biblio|check-session|copyright|log-file|root-info|prep-boot|*-list))
  6287.             _filedir
  6288.             return 0
  6289.             ;;
  6290.         -*-charset)
  6291.             COMPREPLY=( $( mkisofs -input-charset help 2>&1 | \
  6292.                     tail +3 | grep "^$cur") )
  6293.             return 0
  6294.             ;;
  6295.         -uid)
  6296.             _uids
  6297.             return 0
  6298.             ;;
  6299.         -gid)
  6300.             _gids
  6301.             return 0
  6302.             ;;
  6303.     esac
  6304.  
  6305.     if [[ "$cur" == -* ]]; then
  6306.         COMPREPLY=( $( compgen -W '-abstract -A -allow-lowercase \
  6307.                 -allow-multidot -biblio -cache-inodes \
  6308.                 -no-cache-inodes -b -eltorito-alt-boot -B -G \
  6309.                 -hard-disk-boot -no-emul-boot -no-boot \
  6310.                 -boot-load-seg -boot-load-size \
  6311.                 -boot-info-table -C -c -check-oldname \
  6312.                 -check-session -copyright -d -D -dir-mode \
  6313.                 -dvd-video -f -file-mode -gid -gui \
  6314.                 -graft-points -hide -hide-list -hidden \
  6315.                 -hidden-list -hide-joliet -hide-joliet-list \
  6316.                 -hide-joliet-trans-tbl -hide-rr-moved \
  6317.                 -input-charset -output-charset -iso-level -J \
  6318.                 -joliet-long -jcharset -l -L -log-file -m \
  6319.                 -exclude-list -max-iso9660-filenames -M -N \
  6320.                 -new-dir-mode -nobak -no-bak -force-rr -no-rr \
  6321.                 -no-split-symlink-components \
  6322.                 -no-split-symlink-fields -o -pad -no-pad \
  6323.                 -path-list -P -p -print-size -quiet -R -r \
  6324.                 -relaxed-filenames -sort -split-output \
  6325.                 -stream-media-size -stream-file-name -sysid -T\
  6326.                 -table-name -ucs-level -udf -uid \
  6327.                 -use-fileversion -U -no-iso-translate -V \
  6328.                 -volset -volset-size -volset-seqno -v -x -z \
  6329.                 -hfs -apple -map -magic -hfs-creator \
  6330.                 -hfs-type -probe -no-desktop -mac-name \
  6331.                 -boot-hfs-file -part -auto -cluster-size \
  6332.                 -hide-hfs -hide-hfs-list -hfs-volid \
  6333.                 -icon-position -root-info -prep-boot \
  6334.                 -input-hfs-charset -output-hfs-charset \
  6335.                 -hfs-unlock -hfs-bless -hfs-parms --cap \
  6336.                 --netatalk --double --ethershare --ushare \
  6337.                 --exchange --sgi --xinet --macbin --single \
  6338.                 --dave --sfm --osx-double --osx-hfs' -- $cur ))
  6339.     else
  6340.         _filedir
  6341.     fi
  6342.  
  6343. } &&
  6344. complete -F _mkisofs $filenames mkisofs
  6345.  
  6346. # mc(1) completion
  6347. #
  6348. have mc &&
  6349. _mc()
  6350. {
  6351.     local cur prev
  6352.  
  6353.     COMPREPLY=()
  6354.     cur=`_get_cword`
  6355.     prev=${COMP_WORDS[COMP_CWORD-1]}
  6356.  
  6357.     # -name value style option
  6358.     case "$prev" in
  6359.         -@(e|v|l|P))
  6360.             _filedir
  6361.             return 0
  6362.             ;;
  6363.     esac
  6364.  
  6365.     # --name=value style option
  6366.     if [[ "$cur" == *=* ]]; then
  6367.         prev=${cur/=*/}
  6368.         cur=${cur/*=/}
  6369.         case "$prev" in
  6370.             --@(edit|view|ftplog|printwd))
  6371.                 _filedir
  6372.                 return 0
  6373.                 ;;
  6374.         esac
  6375.     fi
  6376.  
  6377.     if [[ "$cur" == -* ]]; then
  6378.         COMPREPLY=( $( compgen -W '-a --stickchars -b --nocolor -c \
  6379.             --color -C --colors= -d --nomouse -e --edit= -f \
  6380.             --datadir -k --resetsoft -l --ftplog= -P --printwd= \
  6381.             -s --slow -t --termcap -u --nosubshell -U --subshell \
  6382.             -v --view= -V --version -x --xterm -h --help' -- $cur ) )
  6383.     else
  6384.         _filedir -d
  6385.     fi
  6386. } &&
  6387. complete -F _mc $filenames mc
  6388.  
  6389. # yum(8) completion
  6390. #
  6391. have yum && {
  6392. _yum()
  6393. {
  6394.     local cur prev special
  6395.     
  6396.     COMPREPLY=()
  6397.     cur=`_get_cword`
  6398.     prev=${COMP_WORDS[COMP_CWORD-1]}
  6399.  
  6400.     for (( i=0; i < ${#COMP_WORDS[@]}-1; i++ )); do
  6401.         if [[ ${COMP_WORDS[i]} == @(install|update|upgrade|remove|erase|deplist) ]]; then
  6402.             special=${COMP_WORDS[i]}
  6403.         fi
  6404.     done
  6405.  
  6406.     if [ -n "$special" ]; then
  6407.         case $special in
  6408.         install|deplist)
  6409.             COMPREPLY=( $( compgen -W '$( yum -C list | cut -d" " -f1 )' -- $cur ) )
  6410.             return 0
  6411.             ;;
  6412.         *)
  6413.             _rpm_installed_packages
  6414.             return 0
  6415.             ;;
  6416.         esac
  6417.     fi
  6418.  
  6419.     case $cur in
  6420.         --*)
  6421.         COMPREPLY=( $( compgen -W '--installroot --version --help --enablerepo --disablerepo --exclude --obsoletes --noplugins' -- $cur ) )
  6422.         return 0
  6423.         ;;
  6424.         -*)
  6425.         COMPREPLY=( $( compgen -W '-c -e -d -y -t -R -C -h' -- $cur ) )
  6426.         return 0
  6427.         ;;
  6428.     esac
  6429.  
  6430.     case $prev in
  6431.         list)
  6432.         COMPREPLY=( $( compgen -W 'all available updates installed extras obsoletes recent' -- $cur ) )
  6433.         ;;
  6434.         clean)
  6435.         COMPREPLY=( $( compgen -W 'packages headers metadata cache dbcache all' -- $cur ) )
  6436.         ;;
  6437.         localinstall)
  6438.         _filedir rpm
  6439.         ;;
  6440.         -c)
  6441.         _filedir
  6442.         ;;
  6443.         --installroot)
  6444.         _filedir -d
  6445.         ;;
  6446.         *)
  6447.         COMPREPLY=( $( compgen -W 'install update check-update upgrade remove list \
  6448.                         search info provides clean groupinstall groupupdate \
  6449.                         grouplist deplist erase groupinfo groupremove \
  6450.                         localinstall localupdate makecache resolvedep \
  6451.                         shell whatprovides' -- $cur ) )
  6452.         ;;
  6453.     esac
  6454. }
  6455. complete -F _yum $filenames yum
  6456.  
  6457. # yum-arch(8) completion
  6458. #
  6459. _yum_arch()
  6460. {
  6461.     local cur
  6462.     COMPREPLY=()
  6463.     cur=`_get_cword`
  6464.  
  6465.     case "$cur" in
  6466.     -*)
  6467.         COMPREPLY=( $( compgen -W '-d -v -vv -n -c -z -s -l -q' -- $cur ) )
  6468.         ;;
  6469.     *)
  6470.         _filedir -d
  6471.         ;;
  6472.     esac
  6473.  
  6474.     return 0
  6475.  
  6476. }
  6477. complete -F _yum_arch $filenames yum-arch
  6478. }
  6479.  
  6480. # ImageMagick completion
  6481. #
  6482. have convert && {
  6483. _ImageMagick()
  6484. {
  6485.     local prev
  6486.     prev=${COMP_WORDS[COMP_CWORD-1]}
  6487.  
  6488.     case "$prev" in
  6489.         -channel)
  6490.             COMPREPLY=( $( compgen -W 'Red Green Blue Opacity \
  6491.                 Matte Cyan Magenta Yellow Black' -- $cur ) )
  6492.             return 0
  6493.             ;;
  6494.         -colormap)
  6495.             COMPREPLY=( $( compgen -W 'shared private' -- $cur ) )
  6496.             return 0
  6497.             ;;
  6498.         -colorspace)
  6499.             COMPREPLY=( $( compgen -W 'GRAY OHTA RGB Transparent \
  6500.                 XYZ YCbCr YIQ YPbPr YUV CMYK' -- $cur ) )
  6501.             return 0
  6502.             ;;
  6503.         -compose)
  6504.             COMPREPLY=( $( compgen -W 'Over In Out Atop Xor Plus \
  6505.                 Minus Add Subtract Difference Multiply Bumpmap\
  6506.                 Copy CopyRed CopyGreen CopyBlue CopyOpacity' \
  6507.                 -- $cur ) )
  6508.             return 0
  6509.             ;;
  6510.         -compress)
  6511.             COMPREPLY=( $( compgen -W 'None BZip Fax Group4 JPEG \
  6512.                 Lossless LZW RLE Zip' -- $cur ) )
  6513.             return 0
  6514.             ;;
  6515.         -dispose)
  6516.             COMPREPLY=( $( compgen -W 'Undefined None Background \
  6517.                             Previous' -- $cur ) )
  6518.             return 0
  6519.             ;;
  6520.         -encoding)
  6521.             COMPREPLY=( $( compgen -W 'AdobeCustom AdobeExpert \
  6522.                 AdobeStandard AppleRoman BIG5 GB2312 Latin2 \
  6523.                 None SJIScode Symbol Unicode Wansung' -- $cur))
  6524.             return 0
  6525.             ;;
  6526.         -endian)
  6527.             COMPREPLY=( $( compgen -W 'MSB LSB' -- $cur ) )
  6528.             return 0
  6529.             ;;
  6530.         -filter)
  6531.             COMPREPLY=( $( compgen -W 'Point Box Triangle Hermite \
  6532.                 Hanning Hamming Blackman Gaussian Quadratic \
  6533.                 Cubic Catrom Mitchell Lanczos Bessel Sinc' \
  6534.                 -- $cur ) )
  6535.             return 0
  6536.             ;;
  6537.         -format)
  6538.             COMPREPLY=( $( convert -list format | \
  6539.                     awk '/ [r-][w-][+-] / {print $1}' | \
  6540.                     tr -d '*' | tr [:upper:] [:lower:] | \
  6541.                     grep "^$cur" ) )
  6542.             return 0
  6543.             ;;
  6544.         -gravity)
  6545.             COMPREPLY=( $( compgen -W 'Northwest North NorthEast \
  6546.                 West Center East SouthWest South SouthEast' \
  6547.                 -- $cur ) )
  6548.             return 0
  6549.             ;;
  6550.         -intent)
  6551.             COMPREPLY=( $( compgen -W 'Absolute Perceptual \
  6552.                     Relative Saturation' -- $cur ) )
  6553.             return 0
  6554.             ;;
  6555.         -interlace)
  6556.             COMPREPLY=( $( compgen -W 'None Line Plane Partition' \
  6557.                     -- $cur ) )
  6558.             return 0
  6559.             ;;
  6560.         -limit)
  6561.             COMPREPLY=( $( compgen -W 'Disk File Map Memory' \
  6562.                     -- $cur ) )
  6563.             return 0
  6564.             ;;
  6565.         -list)
  6566.             COMPREPLY=( $( compgen -W 'Delegate Format Magic \
  6567.                     Module Resource Type' -- $cur ) )
  6568.             return 0
  6569.             ;;
  6570.         -map)
  6571.             COMPREPLY=( $( compgen -W 'best default gray red \
  6572.                     green blue' -- $cur ) )
  6573.             _filedir
  6574.             return 0
  6575.             ;;
  6576.         -noise)
  6577.             COMPREPLY=( $( compgen -W 'Uniform Gaussian \
  6578.                     Multiplicative \
  6579.                 Impulse Laplacian Poisson' -- $cur ) )
  6580.             return 0
  6581.             ;;
  6582.         -preview)
  6583.             COMPREPLY=( $( compgen -W 'Rotate Shear Roll Hue \
  6584.                     Saturation Brightness Gamma Spiff \
  6585.                     Dull Grayscale Quantize Despeckle \
  6586.                     ReduceNoise AddNoise Sharpen Blur \
  6587.                     Treshold EdgeDetect Spread Shade \
  6588.                     Raise Segment Solarize Swirl Implode \
  6589.                     Wave OilPaint CharcoalDrawing JPEG' \
  6590.                     -- $cur ) )
  6591.             return 0
  6592.             ;;
  6593.         -@(mask|profile|texture|tile|write))
  6594.             _filedir
  6595.             return 0
  6596.             ;;
  6597.         -type)
  6598.             COMPREPLY=( $( compgen -W 'Bilevel Grayscale Palette \
  6599.                     PaletteMatte TrueColor TrueColorMatte \
  6600.                     ColorSeparation ColorSeparationlMatte \
  6601.                     Optimize' -- $cur ) )
  6602.             return 0
  6603.             ;;
  6604.         -units)
  6605.             COMPREPLY=( $( compgen -W 'Undefined PixelsPerInch \
  6606.                     PixelsPerCentimeter' -- $cur ) )
  6607.             return 0
  6608.             ;;
  6609.         -virtual-pixel)
  6610.             COMPREPLY=( $( compgen -W 'Constant Edge mirror tile' \
  6611.                     -- $cur ) )
  6612.             return 0
  6613.             ;;
  6614.         -visual)
  6615.             COMPREPLY=( $( compgen -W 'StaticGray GrayScale \
  6616.                     StaticColor PseudoColor TrueColor \
  6617.                     DirectColor defaut visualid' -- $cur ))
  6618.             return 0
  6619.             ;;
  6620.     esac
  6621. }
  6622.  
  6623. _convert()
  6624. {
  6625.     local cur
  6626.  
  6627.     COMPREPLY=()
  6628.     cur=`_get_cword`
  6629.  
  6630.     _ImageMagick
  6631.  
  6632.     if [[ "$cur" == -* ]]; then
  6633.         COMPREPLY=( $( compgen -W '-adjoin -affine -antialias -append \
  6634.             -authenticate -average -background -black-threshold \
  6635.             -blue-primary -blur -border -bordercolor -channel \
  6636.             -charcoal -chop -clip -coalesce -colorize -colors \
  6637.             -colorspace -comment -compress -contrast -convolve \
  6638.             -crop -cycle -debug -deconstruct -delay -density \
  6639.             -depth -despeckle -display -dispose -dither -draw \
  6640.             -edge -emboss -encoding -endian -enhance -equalize \
  6641.             -extract -fill -filter -flatten -flip -flop -font \
  6642.             -frame -fuzz -gamma -gaussian -geometry \
  6643.             -green-primary -gravity -help -implode -intent \
  6644.             -interlace -label -lat -level -limit -list -log -loop \
  6645.             -map -mask -matte -median -modulate -monochrome \
  6646.             -morph -mosaic -negate -noop -noise -normalize \
  6647.             -opaque -ordered-dither -page -paint -ping -pointsize \
  6648.             -preview -profile -quality -raise -random-threshold \
  6649.             -region -raise -red-primary -render -resize -resample \
  6650.             -roll -rotate -sample -sampling-factor -scale -scene \
  6651.             -seed -segment -shade -sharpen -shave -shear -size \
  6652.             -solarize -spread -stroke -strokewidth -swirl \
  6653.             -texture -threshold -thumbnail -tile -transform \
  6654.             -transparent -treedepth -trim -type -undercolor \
  6655.             -units -unsharp -verbose -version -view \
  6656.             -virtual-pixel -wave -white-point -white-threshold \
  6657.             -write' -- $cur ) )
  6658.     elif [[ "$cur" == +* ]]; then
  6659.         COMPREPLY=( $( compgen -W '+adjoin +append +compress \
  6660.             +contrast +debug +dither +endian +gamma +label +map \
  6661.             +mask +matte +negate +noise +page +raise +render \
  6662.             +write' -- $cur ) ) 
  6663.     else
  6664.         _filedir
  6665.     fi
  6666. }
  6667. complete -F _convert $filenames convert
  6668.  
  6669. _mogrify()
  6670. {
  6671.     local cur
  6672.  
  6673.     COMPREPLY=()
  6674.     cur=`_get_cword`
  6675.  
  6676.     _ImageMagick
  6677.  
  6678.     if [[ "$cur" == -* ]]; then
  6679.         COMPREPLY=( $( compgen -W '-affine -antialias -authenticate \
  6680.             -background -black-threshold -blue-primary -blur \
  6681.             -border -bordercolor -channel -charcoal -chop \
  6682.             -colorize -colors -colorspace -comment -compress \
  6683.             -contrast -convolve -crop -cycle -debug -delay \
  6684.             -density -depth -despeckle -display -dispose -dither \
  6685.             -draw -edge -emboss -encoding -endian -enhance \
  6686.             -equalize -extract -fill -filter -flip -flop -font \
  6687.             -format -frame -fuzz -gamma -gaussian -geometry \
  6688.             -green-primary -implode -interlace -help -label -lat \
  6689.             -level -limit -list -log -loop -map -mask -matte \
  6690.             -median -modulate -monochrome -negate -noop \
  6691.             -normalize -opaque -page -paint -fill -ordered-dither \
  6692.             -pointsize -profile -quality -raise -random-threshold \
  6693.             -red-primary -region -resample -resize -roll -rotate \
  6694.             -sample -sampling-factor -scale -scene -seed -segment \
  6695.             -shade -sharpen -shear -size -solarize -spread \
  6696.             -stroke -strokewidth -swirl -texture -threshold \
  6697.             -thumbnail -tile -transform -transparent -treedepth \
  6698.             -trim -type -undercolor -units -unsharp -verbose \
  6699.             -version -view -virtual-pixel -wave -white-point \
  6700.             -white-threshold' -- $cur ) )
  6701.     elif [[ "$cur" == +* ]]; then
  6702.         COMPREPLY=( $( compgen -W '+compress +contrast +debug +dither \
  6703.             +endian +gamma +label +map +mask +matte +negate +page \
  6704.             +raise' -- $cur ) ) 
  6705.     else
  6706.         _filedir
  6707.     fi
  6708. }
  6709. complete -F _mogrify $filenames mogrify
  6710.  
  6711. _display()
  6712. {
  6713.     local cur
  6714.  
  6715.     COMPREPLY=()
  6716.     cur=`_get_cword`
  6717.  
  6718.     _ImageMagick
  6719.  
  6720.     if [[ "$cur" == -* ]]; then
  6721.         COMPREPLY=( $( compgen -W '-authenticate -backdrop -border \
  6722.             -colormap -colors -colorspace -comment -compress \
  6723.             -contrast -crop -debug -delay -density -depth \
  6724.             -despeckle -display -dispose -dither -edge -endian \
  6725.             -enhance -extract -filter -flip -flop -frame -gamma \
  6726.             -geometry -help -immutable -interlace -label -limit \
  6727.             -log -map -matte -monochrome -negate -noop -page \
  6728.             -quality -raise -remote -roll -rotate -sample \
  6729.             -sampling-factor -scene -segment -sharpen -size \
  6730.             -texture -treedepth -trim -update -verbose -version \
  6731.             -virtual-pixel -window -window_group -write' -- $cur))
  6732.     elif [[ "$cur" == +* ]]; then
  6733.         COMPREPLY=( $( compgen -W '+compress +contrast +debug +dither \
  6734.             +endian +gamma +label +map +matte +negate +page \
  6735.             +raise +write' -- $cur ) ) 
  6736.     else
  6737.         _filedir
  6738.     fi
  6739. }
  6740. complete -F _display $filenames display
  6741.  
  6742. _animate()
  6743. {
  6744.     local cur
  6745.  
  6746.     COMPREPLY=()
  6747.     cur=`_get_cword`
  6748.  
  6749.     _ImageMagick
  6750.  
  6751.     if [[ "$cur" == -* ]]; then
  6752.         COMPREPLY=( $( compgen -W '-authenticate -backdrop -colormap \
  6753.             -colors -colorspace -crop -debug -delay -density \
  6754.             -depth -display -dither -extract -gamma -geometry \
  6755.             -help -interlace -limit -log -matte -map -monochrome \
  6756.             -noop -pause -remote -rotate -sampling-factor -scene \
  6757.             -size -treedepth -trim -verbose -version -visual \
  6758.             -virtual-pixel -window' -- $cur ) )
  6759.     elif [[ "$cur" == +* ]]; then
  6760.         COMPREPLY=( $( compgen -W '+debug +dither +gamma +map +matte' -- $cur ) ) 
  6761.     else
  6762.         _filedir
  6763.     fi
  6764. }
  6765. complete -F _animate $filenames animate
  6766.  
  6767. _identify()
  6768. {
  6769.     local cur
  6770.  
  6771.     COMPREPLY=()
  6772.     cur=`_get_cword`
  6773.  
  6774.     _ImageMagick
  6775.  
  6776.     if [[ "$cur" == -* ]]; then
  6777.         COMPREPLY=( $( compgen -W '-authenticate -debug -density \
  6778.             -depth -extract -format -help -interlace -limit -list \
  6779.             -log -size -sampling-factor -verbose -version \
  6780.             -virtual-pixel' -- $cur ) )
  6781.     elif [[ "$cur" == +* ]]; then
  6782.         COMPREPLY=( $( compgen -W '+debug ' -- $cur ) ) 
  6783.     else
  6784.         _filedir
  6785.     fi
  6786. }
  6787. complete -F _identify $filenames identify
  6788.  
  6789. _montage()
  6790. {
  6791.     local cur
  6792.  
  6793.     COMPREPLY=()
  6794.     cur=`_get_cword`
  6795.  
  6796.     _ImageMagick
  6797.  
  6798.     if [[ "$cur" == -* ]]; then
  6799.         COMPREPLY=( $( compgen -W '-adjoin -affine -authenticate \
  6800.             -blue-primary -blur -colors -colorspace -comment \
  6801.             -compose -compress -crop -debug -density -depth \
  6802.             -display -dispose -dither -draw -encoding -endian \
  6803.             -extract -fill -filter -flip -flop -frame -gamma \
  6804.             -geometry -gravity -green-primary -interlace -help \
  6805.             -label -limit -log -matte -mode -monochrome -noop \
  6806.             -page -pointsize -quality -red-primary -resize \
  6807.             -rotate -sampling-factor -scene -shadow -size \
  6808.             -stroke -texture -thumbnail -tile -transform \
  6809.             -transparent -treedepth -trim -type -verbose \
  6810.             -version -virtual-pixel -white-point' -- $cur ) )
  6811.     elif [[ "$cur" == +* ]]; then
  6812.         COMPREPLY=( $( compgen -W '+adjoin +compress +debug +dither \
  6813.             +endian +gamma +label +matte +page' -- $cur ) ) 
  6814.     else
  6815.         _filedir
  6816.     fi
  6817. }
  6818. complete -F _montage $filenames montage
  6819.  
  6820. _composite()
  6821. {
  6822.     local cur
  6823.  
  6824.     COMPREPLY=()
  6825.     cur=`_get_cword`
  6826.  
  6827.     _ImageMagick
  6828.  
  6829.     if [[ "$cur" == -* ]]; then
  6830.         COMPREPLY=( $( compgen -W '-affine -authenticate \
  6831.             -blue-primary -colors -colorspace -comment -compose \
  6832.             -compress -debug -density -depth -displace -display \
  6833.             -dispose -dissolve -dither -encoding -endian -extract \
  6834.             -filter -font -geometry -gravity -green-primary -help \
  6835.             -interlace -label -limit -log -matte -monochrome \
  6836.             -negate -page -profile -quality -red-primary -rotate \
  6837.             -resize -sampling-factor -scene -sharpen -size \
  6838.             -stegano -stereo -thumbnail -tile -transform \
  6839.             -treedepth -type -units -unsharp -verbose -version \
  6840.             -virtual-pixel -watermark -white-point -write' \
  6841.             -- $cur ) )
  6842.     elif [[ "$cur" == +* ]]; then
  6843.         COMPREPLY=( $( compgen -W '+compress +debug +dither +endian +label \
  6844.             +matte +negate +page +write' -- $cur ) ) 
  6845.     else
  6846.         _filedir
  6847.     fi
  6848. }
  6849. complete -F _composite $filenames composite
  6850. }
  6851.  
  6852. # dd(1) completion
  6853. #
  6854. have dd &&
  6855. _dd()
  6856. {
  6857.      local cur
  6858.  
  6859.      COMPREPLY=()
  6860.     cur=`_get_cword`
  6861.  
  6862.      case "$cur" in
  6863.      if=*|of=*)
  6864.          cur=${cur#*=}
  6865.          _filedir
  6866.          return 0
  6867.          ;;
  6868.      conv=*)
  6869.          cur=${cur#*=}
  6870.          COMPREPLY=( $( compgen -W 'ascii ebcdic ibm block unblock \
  6871.                 lcase notrunc ucase swab noerror sync' \
  6872.                 -- $cur ) )
  6873.          return 0
  6874.          ;;
  6875.      esac
  6876.  
  6877.      _expand || return 0
  6878.  
  6879.      COMPREPLY=( $( compgen -W '--help --version' -- $cur ) \
  6880.              $( compgen -W 'bs cbs conv count ibs if obs of seek skip'\
  6881.                 -S '=' -- $cur ) )
  6882. } &&
  6883. complete -F _dd $nospace $filenames dd
  6884.  
  6885. # CUPS cancel(1) completion
  6886. #
  6887. have cancel &&
  6888. _cancel()
  6889. {
  6890.     local cur
  6891.  
  6892.     COMPREPLY=()
  6893.     cur=`_get_cword`
  6894.  
  6895.     COMPREPLY=( $( lpstat | cut -d' ' -f1 | grep "^$cur" ) )
  6896. } &&
  6897. complete -F _cancel $filenames cancel
  6898.  
  6899. # aspell(1) completion
  6900. #
  6901. have aspell && {
  6902. _aspell_dictionary()
  6903. {
  6904.     local datadir
  6905.     datadir=/usr/lib/aspell
  6906.     COMPREPLY=( $( command ls $datadir/*.@(multi|alias) ) )
  6907.     COMPREPLY=( ${COMPREPLY[@]%.@(multi|alias)} )
  6908.     COMPREPLY=( $( compgen -W '${COMPREPLY[@]#$datadir/}' -- $cur ) )
  6909. }
  6910.  
  6911. _aspell()
  6912. {
  6913.     local cur prev
  6914.  
  6915.     COMPREPLY=()
  6916.     cur=`_get_cword`
  6917.     prev=${COMP_WORDS[COMP_CWORD-1]}
  6918.  
  6919.     # --name value style option
  6920.     case "$prev" in
  6921.         @(-c|-p|check))
  6922.             _filedir
  6923.             return 0
  6924.             ;;
  6925.         @(dump|create|merge))
  6926.             COMPREPLY=( $( compgen -W 'master personal repl' -- $cur ) )
  6927.             return 0
  6928.             ;;
  6929.         -d)
  6930.             _aspell_dictionary
  6931.             return 0
  6932.             ;;
  6933.     esac
  6934.  
  6935.     # --name=value style option
  6936.     if [[ "$cur" == *=* ]]; then
  6937.         prev=${cur/=*/}
  6938.         cur=${cur/*=/}
  6939.         case "$prev" in
  6940.             --@(conf|personal|repl|per-conf))
  6941.                 _filedir
  6942.                 return 0
  6943.                 ;;
  6944.             --@(conf-dir|data-dir|dict-dir|home-dir|local-data-dir|prefix))
  6945.                 _filedir -d
  6946.                 return 0
  6947.                 ;;
  6948.             --master)
  6949.                 _aspell_dictionary
  6950.                 return 0
  6951.                 ;;
  6952.             --mode)
  6953.                 COMPREPLY=( $( compgen -W 'none url email sgml tex' -- $cur ) )
  6954.                 return 0
  6955.                 ;; 
  6956.             --sug-mode)
  6957.                 COMPREPLY=( $( compgen -W 'ultra fast normal bad-speller' -- $cur ) )
  6958.                 return 0
  6959.                 ;;
  6960.             --keymapping)
  6961.                 COMPREPLY=( $( compgen -W 'aspell ispell' -- $cur ) )
  6962.                 return 0
  6963.                 ;;
  6964.         esac
  6965.     fi
  6966.  
  6967.     if [[ "$cur" == -* ]]; then
  6968.         COMPREPLY=( $( compgen -W '--conf= --conf-dir= --data-dir= --dict-dir= \
  6969.             --encoding= --add-filter= --rem-filter= --mode= -e \
  6970.             -H -t --add-extra-dicts= --rem-extra-dicts= \
  6971.             --home-dir= -W --ignore= --ignore-accents \
  6972.             --dont-ignore-accents --ignore-case --dont-ignore-case \
  6973.             --ignore-repl --dont-ignore-repl --jargon= --keyboard= \
  6974.             --lang= --language-tag= --local-data-dir= -d --master= \
  6975.             --module= --add-module-search-order= \
  6976.             --rem-module-search-order= --per-conf= -p --personal= \
  6977.             --prefix= --repl= -C -B --run-together --dont-run-together \
  6978.             --run-together-limit= --run-together-min= --save-repl \
  6979.             --dont-save-repl --set-prefix --dont-set-prefix --size= \
  6980.             --spelling= --strip-accents --dont-strip-accents \
  6981.             --sug-mode= --add-word-list-path= --rem-word-list-path= \
  6982.             -b -x --backup -b|-x --dont-backup --reverse --dont-reverse \
  6983.             --time --dont-time --keymapping= --add-email-quote= \
  6984.             --rem-email-quote= --email-margin= --add-tex-command= \
  6985.             --rem-tex-command= --tex-check-comments \
  6986.             --dont-tex-check-comments --add-tex-extension= \
  6987.             --rem-tex-extension= --add-sgml-check= --rem-sgml-check= \
  6988.             --add-sgml-extension= --rem-sgml-extension=' -- $cur ) )
  6989.     else
  6990.         COMPREPLY=( $( compgen -W '-? help -c check -a pipe -l list \
  6991.             config config soundslike filter -v version dump \
  6992.             create merge' -- $cur ) )
  6993.     fi
  6994.  
  6995. }
  6996. complete -F _aspell $filenames aspell
  6997. }
  6998.  
  6999. # xmms(1) completion
  7000. #
  7001. have xmms &&
  7002. _xmms()
  7003. {
  7004.     local cur
  7005.  
  7006.     COMPREPLY=()
  7007.     cur=`_get_cword`
  7008.  
  7009.     if [[ "$cur" == -* ]]; then
  7010.         COMPREPLY=( $( compgen -W '-h --help -r --rew -p --play \
  7011.             -u --pause -s --stop -t --play-pause -f --fwd -e \
  7012.             --enqueue -m --show-main-window -i --sm-client-id \
  7013.             -v --version' -- $cur ) )
  7014.     else
  7015.         _filedir '@(mp[23]|MP[23]|ogg|OGG|wav|WAV|pls|m3u|xm|mod|s[3t]m|it|mtm|ult|flac)'
  7016.  
  7017.     fi
  7018.  
  7019. } &&
  7020. complete -F _xmms $filenames xmms
  7021.  
  7022. # info(1) completion
  7023. #
  7024. have info &&
  7025. _info()
  7026. {
  7027.     local cur infopath UNAME
  7028.  
  7029.     COMPREPLY=()
  7030.     cur=`_get_cword`
  7031.  
  7032.     _expand || return 0
  7033.  
  7034.     # default completion if parameter contains /
  7035.     if [[ "$cur" == */* ]]; then
  7036.         _filedir
  7037.         return 0
  7038.     fi
  7039.  
  7040.     infopath='/usr/share/info'
  7041.  
  7042.     if [ "${INFOPATH: -1:1}" == ':' ]; then
  7043.         infopath=${INFOPATH}${infopath}
  7044.     elif [ ${INFOPATH:+set} ]; then
  7045.         infopath=$INFOPATH
  7046.     fi
  7047.  
  7048.     infopath=$infopath:
  7049.     if [ -n "$cur" ]; then
  7050.         infopath="${infopath//://$cur* }"
  7051.     else
  7052.         infopath="${infopath//:// }"
  7053.     fi
  7054.  
  7055.     # redirect stderr for when path doesn't exist
  7056.     COMPREPLY=( $( eval command ls "$infopath" 2>/dev/null ) )
  7057.     # weed out directory path names and paths to info pages
  7058.     COMPREPLY=( ${COMPREPLY[@]##*/?(:)} )
  7059.     # weed out info dir file
  7060.     for (( i=0 ; i < ${#COMPREPLY[@]} ; ++i )); do
  7061.         if [ "${COMPREPLY[$i]}" == 'dir' ]; then
  7062.             unset COMPREPLY[$i];
  7063.         fi;
  7064.     done  
  7065.     # strip suffix from info pages
  7066.     COMPREPLY=( ${COMPREPLY[@]%.@(gz|bz2)} )
  7067.     COMPREPLY=( $( compgen -W '${COMPREPLY[@]%.*}' -- "${cur//\\\\/}" ) )
  7068.  
  7069.     return 0
  7070. } &&
  7071. complete -F _info $filenames info
  7072.  
  7073. # dhclient(1) completion
  7074. #
  7075. have dhclient && _dhclient()
  7076. {
  7077.     local cur prev
  7078.  
  7079.     COMPREPLY=()
  7080.     cur=`_get_cword`
  7081.     prev=${COMP_WORDS[COMP_CWORD-1]}
  7082.  
  7083.     case "$prev" in
  7084.         -@(cf|lf|pf|sf))
  7085.             _filedir
  7086.             return 0
  7087.             ;;
  7088.         -s)
  7089.             _known_hosts
  7090.             return 0
  7091.             ;;
  7092.     esac
  7093.  
  7094.     if [[ "$cur" == -* ]]; then
  7095.         COMPREPLY=( $( compgen -W '-p -d -q -1 -r -lf -pf \
  7096.             -cf -sf -s -g -n -nw -w' -- $cur ) )
  7097.     else
  7098.         _available_interfaces
  7099.     fi
  7100. } &&
  7101. complete -F _dhclient dhclient
  7102.  
  7103. # lvm(8) completion
  7104. #
  7105. have lvm && {
  7106. _volumegroups()
  7107. {
  7108.     COMPREPLY=( $(compgen -W "$( vgscan 2>/dev/null | \
  7109.         sed -n -e 's|.*Found.*"\(.*\)".*$|\1|p' )" -- $cur ) )
  7110. }
  7111.  
  7112. _physicalvolumes()
  7113. {
  7114.     COMPREPLY=( $(compgen -W "$( pvscan 2>/dev/null | \
  7115.         sed -n -e 's|^.*PV \(.*\) VG.*$|\1|p' )" -- $cur ) )
  7116. }
  7117.  
  7118. _logicalvolumes()
  7119. {
  7120.     COMPREPLY=( $(compgen -W "$( lvscan 2>/dev/null | \
  7121.         sed -n -e "s|^.*'\(.*\)'.*$|\1|p" )" -- $cur ) )
  7122. }
  7123.  
  7124. _units()
  7125. {
  7126.     COMPREPLY=( $( compgen -W 'h s b k m g t H K M G T' -- $cur ) )
  7127. }
  7128.  
  7129. _sizes()
  7130. {
  7131.     COMPREPLY=( $( compgen -W 'k K m M g G t T' -- $cur ) )
  7132. }
  7133.  
  7134. _args()
  7135. {
  7136.     args=0
  7137.     if [[ "${COMP_WORDS[0]}" == lvm ]]; then
  7138.         offset=2
  7139.     else
  7140.         offset=1
  7141.     fi
  7142.     for (( i=$offset; i < COMP_CWORD; i++ )); do
  7143.         if [[ "${COMP_WORDS[i]}" != -* ]]; then
  7144.             args=$(($args + 1))
  7145.         fi
  7146.     done
  7147. }
  7148.  
  7149. _lvmdiskscan()
  7150. {
  7151.     local cur
  7152.  
  7153.     COMPREPLY=()
  7154.     cur=`_get_cword`
  7155.  
  7156.     if [[ "$cur" == -* ]]; then
  7157.         COMPREPLY=( $( compgen -W '-d --debug -h -? --help -l \
  7158.             --lvmpartition -v --verbose --version' -- $cur ) )
  7159.     fi
  7160. }
  7161. complete -F _lvmdiskscan lvmdiskscan
  7162.  
  7163. _pvscan()
  7164. {
  7165.     local cur
  7166.  
  7167.     COMPREPLY=()
  7168.     cur=`_get_cword`
  7169.  
  7170.     if [[ "$cur" == -* ]]; then
  7171.         COMPREPLY=( $( compgen -W '-d --debug -e \
  7172.             --exported -n --novolumegroup -h -? \
  7173.             --help --ignorelockingfailure -P \
  7174.             --partial -s --short -u --uuid -v \
  7175.             --verbose --version' -- $cur ) )
  7176.     fi
  7177. }
  7178. complete -F _pvscan pvscan
  7179.  
  7180. _pvs()
  7181. {
  7182.     local cur prev
  7183.  
  7184.     COMPREPLY=()
  7185.     cur=`_get_cword`
  7186.     prev=${COMP_WORDS[COMP_CWORD-1]}
  7187.  
  7188.     case "$prev" in
  7189.         -@(o|O|-options|-sort))
  7190.             COMPREPLY=( $( compgen -W 'pv_fmt pv_uuid \
  7191.                 pv_size pv_free pv_used pv_name \
  7192.                 pv_attr pv_pe_count \
  7193.                 pv_pe_alloc_count' -- $cur ) )
  7194.             return 0
  7195.             ;;
  7196.         --units)
  7197.             _units
  7198.             return 0
  7199.             ;;
  7200.     esac
  7201.  
  7202.     if [[ "$cur" == -* ]]; then
  7203.         COMPREPLY=( $( compgen -W '--aligned -a --all -d --debug \
  7204.             -h -? --help --ignorelockingfailure --noheadings \
  7205.             --nosuffix -o --options -O --sort \
  7206.             --separator --unbuffered --units \
  7207.             -v --verbose --version' -- $cur ) )
  7208.     else
  7209.         _physicalvolumes
  7210.     fi
  7211. }
  7212. complete -F _pvs pvs
  7213.  
  7214. _pvdisplay()
  7215. {
  7216.     local cur prev
  7217.  
  7218.     COMPREPLY=()
  7219.     cur=`_get_cword`
  7220.     prev=${COMP_WORDS[COMP_CWORD-1]}
  7221.  
  7222.     case "$prev" in
  7223.         --units)
  7224.             _units
  7225.             return 0
  7226.             ;;
  7227.     esac
  7228.  
  7229.     if [[ "$cur" == -* ]]; then
  7230.         COMPREPLY=( $( compgen -W '-c --colon -C --columns --units \
  7231.             -v --verbose -d --debug -h --help --version' -- $cur ) )
  7232.     else
  7233.         _physicalvolumes
  7234.     fi
  7235. }
  7236. complete -F _pvdisplay pvdisplay
  7237.  
  7238. _pvchange()
  7239. {
  7240.     local cur prev
  7241.  
  7242.     COMPREPLY=()
  7243.     cur=`_get_cword`
  7244.     prev=${COMP_WORDS[COMP_CWORD-1]}
  7245.  
  7246.     case "$prev" in
  7247.         -@(A|x|-autobackup|--allocatable))
  7248.             COMPREPLY=( $( compgen -W 'y n' -- $cur ) )
  7249.             return 0
  7250.             ;;
  7251.     esac
  7252.  
  7253.     if [[ "$cur" == -* ]]; then
  7254.         COMPREPLY=( $( compgen -W '-a --all -A --autobackup \
  7255.             -d --debug -h --help -t --test -u --uuid -x \
  7256.             --allocatable -v --verbose --addtag --deltag \
  7257.             --version' -- $cur ) )
  7258.     else
  7259.         _physicalvolumes
  7260.     fi
  7261. }
  7262. complete -F _pvchange pvchange
  7263.  
  7264. _pvcreate()
  7265. {
  7266.     local cur prev
  7267.  
  7268.     COMPREPLY=()
  7269.     cur=`_get_cword`
  7270.     prev=${COMP_WORDS[COMP_CWORD-1]}
  7271.  
  7272.     case "$prev" in
  7273.         --restorefile)
  7274.             _filedir
  7275.             return 0
  7276.             ;;
  7277.         -@(M|-metadatatype))
  7278.             COMPREPLY=( $( compgen -W '1 2' -- $cur ) )
  7279.             return 0
  7280.             ;;
  7281.         --metadatacopies)
  7282.             COMPREPLY=( $( compgen -W '0 1 2' -- $cur ) )
  7283.             return 0
  7284.             ;;
  7285.         --@(metadatasize|setphysicalvolumesize))
  7286.             _sizes
  7287.             return 0
  7288.             ;;
  7289.     esac
  7290.  
  7291.     if [[ "$cur" == -* ]]; then
  7292.         COMPREPLY=( $( compgen -W '--restorefile -d --debug -f \
  7293.             --force -h -? --help --labelsector -M --metadatatype \
  7294.             --metadatacopies --metadatasize \
  7295.             --setphysicalvolumesize -t --test -u --uuid uuid -v \
  7296.             --verbose -y --yes --version' -- $cur ) )
  7297.     else
  7298.         _physicalvolumes
  7299.     fi
  7300. }
  7301. complete -F _pvcreate pvcreate
  7302.  
  7303. _pvmove()
  7304. {
  7305.     local cur prev
  7306.  
  7307.     COMPREPLY=()
  7308.     cur=`_get_cword`
  7309.     prev=${COMP_WORDS[COMP_CWORD-1]}
  7310.  
  7311.     case "$prev" in
  7312.         -@(A|-autobackup))
  7313.             COMPREPLY=( $( compgen -W 'y n' -- $cur ) )
  7314.             return 0
  7315.             ;;
  7316.         -@(n|-name))
  7317.             _logicalvolumes
  7318.             return 0
  7319.     esac
  7320.  
  7321.     if [[ "$cur" == -* ]]; then
  7322.         COMPREPLY=( $( compgen -W '--abort -A --autobackup \
  7323.             -b --background -d --debug -f --force -h -? \
  7324.             --help -i --interval -t --test -v --verbose \
  7325.             --version -n --name' -- $cur ) )
  7326.     else
  7327.         _physicalvolumes
  7328.     fi
  7329. }
  7330. complete -F _pvmove pvmove
  7331.  
  7332. _pvremove()
  7333. {
  7334.     local cur
  7335.  
  7336.     COMPREPLY=()
  7337.     cur=`_get_cword`
  7338.  
  7339.     if [[ "$cur" == -* ]]; then
  7340.         COMPREPLY=( $( compgen -W '-d --debug -f --force -h -? \
  7341.             --help -y --yes -t --test -v --verbose \
  7342.             --version' -- $cur ) )
  7343.     else
  7344.         _physicalvolumes
  7345.     fi
  7346. }
  7347. complete -F _pvremove pvremove
  7348.  
  7349. _vgscan()
  7350. {
  7351.     local cur
  7352.  
  7353.     COMPREPLY=()
  7354.     cur=`_get_cword`
  7355.  
  7356.     if [[ "$cur" == -* ]]; then
  7357.         COMPREPLY=( $( compgen -W '-d --debug -h --help \
  7358.             --ignorelockingfailure --mknodes -P \
  7359.             --partial -v --verbose --version' -- $cur ) )
  7360.     fi
  7361. }
  7362. complete -F _vgscan vgscan
  7363.  
  7364. _vgs()
  7365. {
  7366.     local cur prev
  7367.  
  7368.     COMPREPLY=()
  7369.     cur=`_get_cword`
  7370.     prev=${COMP_WORDS[COMP_CWORD-1]}
  7371.  
  7372.     case "$prev" in
  7373.         -@(o|O|-options|-sort))
  7374.             COMPREPLY=( $( compgen -W 'vg_fmt vg_uuid vg_name \
  7375.                 vg_attr vg_size vg_free vg_sysid \
  7376.                 vg_extent_size vg_extent_count vg_free_count \
  7377.                 max_lv max_pv pv_count lv_count snap_count \
  7378.                 vg_seqno' -- $cur ) )
  7379.             return 0
  7380.             ;;
  7381.         --units)
  7382.             _units
  7383.             return 0
  7384.             ;;
  7385.     esac
  7386.  
  7387.     if [[ "$cur" == -* ]]; then
  7388.         COMPREPLY=( $( compgen -W '--aligned -d --debug \
  7389.             -h --help --ignorelockingfailure --noheadings \
  7390.             --nosuffix -o --options -O --sort -P --partial \
  7391.             --separator --unbuffered --units \
  7392.             -v --verbose --version' -- $cur ) )
  7393.     else
  7394.         _volumegroups
  7395.     fi
  7396. }
  7397. complete -F _vgs vgs
  7398.  
  7399. _vgdisplay()
  7400. {
  7401.     local cur prev
  7402.  
  7403.     COMPREPLY=()
  7404.     cur=`_get_cword`
  7405.     prev=${COMP_WORDS[COMP_CWORD-1]}
  7406.  
  7407.     case "$prev" in
  7408.         --units)
  7409.             _units
  7410.             return 0
  7411.             ;;
  7412.     esac
  7413.  
  7414.     if [[ "$cur" == -* ]]; then
  7415.         COMPREPLY=( $( compgen -W '-c --colon -C --columns --units \
  7416.             -P --partial -A --activevolumegroups -v --verbose \
  7417.             -d --debug -h --help --version' -- $cur ) )
  7418.     else
  7419.         _volumegroups
  7420.     fi
  7421. }
  7422. complete -F _vgdisplay vgdisplay
  7423.  
  7424. _vgchange()
  7425. {
  7426.     local cur prev
  7427.  
  7428.     COMPREPLY=()
  7429.     cur=`_get_cword`
  7430.     prev=${COMP_WORDS[COMP_CWORD-1]}
  7431.  
  7432.     case "$prev" in
  7433.         -@(a|A|x|-available|-autobackup|-resizeable))
  7434.             COMPREPLY=( $( compgen -W 'y n' -- $cur ) )
  7435.             return 0
  7436.             ;;
  7437.     esac
  7438.  
  7439.     if [[ "$cur" == -* ]]; then
  7440.         COMPREPLY=( $( compgen -W '-A --autobackup --alloc -P \
  7441.             --partial -d --debug -h --help --ignorelockingfailure \
  7442.             -t --test -u --uuid -v --verbose --version -a \
  7443.             --available -x --resizeable -l --logicalvolume \
  7444.             --addtag --deltag' -- $cur ) )
  7445.     else
  7446.         _volumegroups
  7447.     fi
  7448. }
  7449. complete -F _vgchange vgchange
  7450.  
  7451. _vgcreate()
  7452. {
  7453.     local cur prev
  7454.  
  7455.     COMPREPLY=()
  7456.     cur=`_get_cword`
  7457.     prev=${COMP_WORDS[COMP_CWORD-1]}
  7458.  
  7459.     case "$prev" in
  7460.         -@(A|-autobackup))
  7461.             COMPREPLY=( $( compgen -W 'y n' -- $cur ) )
  7462.             return 0
  7463.             ;;
  7464.         -@(M|-metadatatype))
  7465.             COMPREPLY=( $( compgen -W '1 2' -- $cur ) )
  7466.             return 0
  7467.             ;;
  7468.         -@(s|-physicalextentsize))
  7469.             _sizes
  7470.             return 0
  7471.             ;;
  7472.     esac
  7473.  
  7474.     if [[ "$cur" == -* ]]; then
  7475.         COMPREPLY=( $( compgen -W '-A --autobackup --addtag \
  7476.             --alloc -d --debug -h --help -l --maxlogicalvolumes \
  7477.             -M --metadatatype -p --maxphysicalvolumes -s \
  7478.             --physicalextentsize -t --test -v --verbose \
  7479.             --version' -- $cur ) )
  7480.     else
  7481.         _args
  7482.         if [ $args -eq 0 ]; then
  7483.             _volumegroups
  7484.         else
  7485.             _physicalvolumes
  7486.         fi
  7487.     fi
  7488. }
  7489. complete -F _vgcreate vgcreate
  7490.  
  7491. _vgremove()
  7492. {
  7493.     local cur
  7494.  
  7495.     COMPREPLY=()
  7496.     cur=`_get_cword`
  7497.  
  7498.     if [[ "$cur" == -* ]]; then
  7499.         COMPREPLY=( $( compgen -W '-d --debug -h --help -t --test \
  7500.         -v --verbose --version' -- $cur ) )
  7501.     else
  7502.         _volumegroups
  7503.     fi
  7504. }
  7505. complete -F _vgremove vgremove
  7506.  
  7507. _vgrename()
  7508. {
  7509.     local cur prev
  7510.  
  7511.     COMPREPLY=()
  7512.     cur=`_get_cword`
  7513.     prev=${COMP_WORDS[COMP_CWORD-1]}
  7514.  
  7515.     case "$prev" in
  7516.         -@(A|-autobackup))
  7517.             COMPREPLY=( $( compgen -W 'y n' -- $cur ) )
  7518.             return 0
  7519.             ;;
  7520.     esac
  7521.  
  7522.     if [[ "$cur" == -* ]]; then
  7523.         COMPREPLY=( $( compgen -W '-A --autobackup -d --debug -h \
  7524.             -? --help -t --test -v --verbose --version' -- $cur ) )
  7525.     else
  7526.         _volumegroups
  7527.     fi
  7528. }
  7529. complete -F _vgrename vgrename
  7530.  
  7531. _vgreduce()
  7532. {
  7533.     local cur prev
  7534.  
  7535.     COMPREPLY=()
  7536.     cur=`_get_cword`
  7537.     prev=${COMP_WORDS[COMP_CWORD-1]}
  7538.  
  7539.     case "$prev" in
  7540.         -@(A|-autobackup))
  7541.             COMPREPLY=( $( compgen -W 'y n' -- $cur ) )
  7542.             return 0
  7543.             ;;
  7544.     esac
  7545.  
  7546.     if [[ "$cur" == -* ]]; then
  7547.         COMPREPLY=( $( compgen -W '-a --all -A --autobackup -d \
  7548.             --debug -h --help --removemissing -t --test -v \
  7549.             --verbose --version' -- $cur ) )
  7550.  
  7551.     else
  7552.         _args
  7553.         if [ $args -eq 0 ]; then
  7554.             _volumegroups
  7555.         else
  7556.             _physicalvolumes
  7557.         fi
  7558.     fi
  7559. }
  7560. complete -F _vgreduce vgreduce
  7561.  
  7562. _vgextend()
  7563. {
  7564.     local cur prev
  7565.  
  7566.     COMPREPLY=()
  7567.     cur=`_get_cword`
  7568.     prev=${COMP_WORDS[COMP_CWORD-1]}
  7569.  
  7570.     case "$prev" in
  7571.         -@(A|-autobackup))
  7572.             COMPREPLY=( $( compgen -W 'y n' -- $cur ) )
  7573.             return 0
  7574.             ;;
  7575.         -@(L|-size))
  7576.             _sizes
  7577.             return 0
  7578.             ;;
  7579.     esac
  7580.  
  7581.     if [[ "$cur" == -* ]]; then
  7582.         COMPREPLY=( $( compgen -W '-A --autobackup -d --debug -h \
  7583.             -? --help -t --test -v --verbose --version' -- $cur ) )
  7584.     else
  7585.         _args
  7586.         if [ $args -eq 0 ]; then
  7587.             _volumegroups
  7588.         else
  7589.             _physicalvolumes
  7590.         fi
  7591.     fi
  7592. }
  7593. complete -F _vgextend vgextend
  7594.  
  7595. _vgport()
  7596. {
  7597.     local cur prev
  7598.  
  7599.     COMPREPLY=()
  7600.     cur=`_get_cword`
  7601.  
  7602.     if [[ "$cur" == -* ]]; then
  7603.         COMPREPLY=( $( compgen -W '-a --all -d --debug -h \
  7604.             -? --help -v --verbose --version' -- $cur ) )
  7605.     else
  7606.         _volumegroups
  7607.     fi
  7608. }
  7609. complete -F _vgport vgimport vgexport
  7610.  
  7611. _vgck()
  7612. {
  7613.     local cur prev
  7614.  
  7615.     COMPREPLY=()
  7616.     cur=`_get_cword`
  7617.  
  7618.     if [[ "$cur" == -* ]]; then
  7619.         COMPREPLY=( $( compgen -W '-d --debug -h \
  7620.             -? --help -v --verbose --version' -- $cur ) )
  7621.     else
  7622.         _volumegroups
  7623.     fi
  7624. }
  7625. complete -F _vgck vgck
  7626.  
  7627. _vgconvert()
  7628. {
  7629.     local cur prev
  7630.  
  7631.     COMPREPLY=()
  7632.     cur=`_get_cword`
  7633.     prev=${COMP_WORDS[COMP_CWORD-1]}
  7634.  
  7635.     case "$prev" in
  7636.         -@(M|-metadatatype))
  7637.             COMPREPLY=( $( compgen -W '1 2' -- $cur ) )
  7638.             return 0
  7639.             ;;
  7640.         --metadatacopies)
  7641.             COMPREPLY=( $( compgen -W '0 1 2' -- $cur ) )
  7642.             return 0
  7643.             ;;
  7644.         --metadatasize)
  7645.             _sizes
  7646.             return 0
  7647.             ;;
  7648.     esac
  7649.  
  7650.     if [[ "$cur" == -* ]]; then
  7651.         COMPREPLY=( $( compgen -W '-d --debug -h --help --labelsector \ 
  7652.             -M --metadatatype --metadatacopies --metadatasize \
  7653.             -t --test -v --verbose --version' -- $cur ) )
  7654.     else
  7655.         _volumegroups
  7656.     fi
  7657. }
  7658. complete -F _vgconvert vgconvert
  7659.  
  7660. _vgcfgbackup()
  7661. {
  7662.     local cur prev
  7663.  
  7664.     COMPREPLY=()
  7665.     cur=`_get_cword`
  7666.     prev=${COMP_WORDS[COMP_CWORD-1]}
  7667.  
  7668.     case "$prev" in
  7669.         -@(f|-file))
  7670.             _filedir
  7671.             return 0
  7672.             ;;
  7673.     esac
  7674.  
  7675.     if [[ "$cur" == -* ]]; then
  7676.         COMPREPLY=( $( compgen -W '-d --debug -f --file -h --help \
  7677.             --ignorelockingfailure -P --partial -v --verbose \
  7678.             --version' -- $cur ) )
  7679.     else
  7680.         _volumegroups
  7681.     fi
  7682. }
  7683. complete -F _vgcfgbackup vgcfgbackup
  7684.  
  7685. _vgcfgrestore()
  7686. {
  7687.     local cur prev
  7688.  
  7689.     COMPREPLY=()
  7690.     cur=`_get_cword`
  7691.     prev=${COMP_WORDS[COMP_CWORD-1]}
  7692.  
  7693.     case "$prev" in
  7694.         -@(f|-file))
  7695.             _filedir
  7696.             return 0
  7697.             ;;
  7698.         -@(M|-metadatatype))
  7699.             COMPREPLY=( $( compgen -W '1 2' -- $cur ) )
  7700.             return 0
  7701.             ;;
  7702.         -@(n|-name))
  7703.             _volumegroups
  7704.             return 0
  7705.             ;;
  7706.     esac
  7707.  
  7708.     if [[ "$cur" == -* ]]; then
  7709.         COMPREPLY=( $( compgen -W '-d --debug -f --file -l --list \
  7710.             -h --help -M --Metadatatype -n --name -t --test \
  7711.             -v --verbose --version' -- $cur ) )
  7712.     else
  7713.         _volumegroups
  7714.     fi
  7715. }
  7716. complete -F _vgcfgrestore vgcfgrestore
  7717.  
  7718. _vgmerge()
  7719. {
  7720.     local cur prev
  7721.  
  7722.     COMPREPLY=()
  7723.     cur=`_get_cword`
  7724.     prev=${COMP_WORDS[COMP_CWORD-1]}
  7725.  
  7726.     case "$prev" in
  7727.         -@(A|-autobackup))
  7728.             COMPREPLY=( $( compgen -W 'y n' -- $cur ) )
  7729.             return 0
  7730.             ;;
  7731.     esac
  7732.  
  7733.     if [[ "$cur" == -* ]]; then
  7734.         COMPREPLY=( $( compgen -W '-A --autobackup -d --debug \
  7735.             -h --help -l --list -t --test -v --verbose \
  7736.             --version' -- $cur ) )
  7737.     else
  7738.         _volumegroups
  7739.     fi
  7740. }
  7741. complete -F _vgmerge vgmerge
  7742.  
  7743. _vgsplit()
  7744. {
  7745.     local cur prev
  7746.  
  7747.     COMPREPLY=()
  7748.     cur=`_get_cword`
  7749.     prev=${COMP_WORDS[COMP_CWORD-1]}
  7750.  
  7751.     case "$prev" in
  7752.         -@(A|-autobackup))
  7753.             COMPREPLY=( $( compgen -W 'y n' -- $cur ) )
  7754.             return 0
  7755.             ;;
  7756.         -@(M|-metadatatype))
  7757.             COMPREPLY=( $( compgen -W '1 2' -- $cur ) )
  7758.             return 0
  7759.             ;;
  7760.     esac
  7761.  
  7762.     if [[ "$cur" == -* ]]; then
  7763.         COMPREPLY=( $( compgen -W '-A --autobackup -d --debug \
  7764.             -h --help -l --list -M --metadatatype -t --test \
  7765.             -v --verbose --version' -- $cur ) )
  7766.     else
  7767.         _args
  7768.         if [ $args -eq 0 -o $args -eq 1 ]; then
  7769.             _volumegroups
  7770.         else
  7771.             _physicalvolumes
  7772.         fi
  7773.     fi
  7774. }
  7775. complete -F _vgsplit vgsplit
  7776.  
  7777. _vgmknodes()
  7778. {
  7779.     local cur
  7780.  
  7781.     COMPREPLY=()
  7782.     cur=`_get_cword`
  7783.  
  7784.     if [[ "$cur" == -* ]]; then
  7785.         COMPREPLY=( $( compgen -W '-d --debug -h --help -v --verbose \
  7786.             --version' -- $cur ) )
  7787.     else
  7788.         _volumegroups
  7789.     fi
  7790. }
  7791. complete -F _vgmknodes vgmknodes
  7792.  
  7793. _lvscan()
  7794. {
  7795.     local cur
  7796.  
  7797.     COMPREPLY=()
  7798.     cur=`_get_cword`
  7799.  
  7800.     if [[ "$cur" == -* ]]; then
  7801.         COMPREPLY=( $( compgen -W '-b --blockdevice -d --debug \
  7802.             -h -? --help --ignorelockingfailure -P \
  7803.             --partial -v --verbose --version' -- $cur ) )
  7804.     fi
  7805. }
  7806. complete -F _lvscan lvscan
  7807.  
  7808. _lvs()
  7809. {
  7810.     local cur prev
  7811.  
  7812.     COMPREPLY=()
  7813.     cur=`_get_cword`
  7814.     prev=${COMP_WORDS[COMP_CWORD-1]}
  7815.  
  7816.     case "$prev" in
  7817.         -@(o|O|-options|-sort))
  7818.             COMPREPLY=( $( compgen -W 'lv_uuid lv_name \
  7819.                 lv_attr lv_minor lv_size seg_count \
  7820.                 origin snap_percent segtype stripes \
  7821.                 stripesize chunksize seg_start \
  7822.                 seg_size' -- $cur ) )
  7823.             return 0
  7824.             ;;
  7825.         --units)
  7826.             _units
  7827.             return 0
  7828.             ;;
  7829.     esac
  7830.  
  7831.     if [[ "$cur" == -* ]]; then
  7832.         COMPREPLY=( $( compgen -W '--aligned -d --debug \
  7833.             -h --help --ignorelockingfailure --noheadings \
  7834.             --nosuffix -o --options -O --sort -P --partial \
  7835.             --segments --separator --unbuffered --units \
  7836.             -v --verbose --version' -- $cur ) )
  7837.     else
  7838.         _logicalvolumes
  7839.     fi
  7840. }
  7841. complete -F _lvs lvs
  7842.  
  7843. _lvdisplay()
  7844. {
  7845.     local cur prev
  7846.  
  7847.     COMPREPLY=()
  7848.     cur=`_get_cword`
  7849.     prev=${COMP_WORDS[COMP_CWORD-1]}
  7850.  
  7851.     case "$prev" in
  7852.         --units)
  7853.             _units
  7854.             return 0
  7855.             ;;
  7856.     esac
  7857.  
  7858.     if [[ "$cur" == -* ]]; then
  7859.         COMPREPLY=( $( compgen -W '-c --colon -C --columns --units \
  7860.             -P --partial -m --maps -v --verbose -d --debug -h \
  7861.             --help --version' -- $cur ) )
  7862.     else
  7863.         _logicalvolumes
  7864.     fi
  7865. }
  7866. complete -F _lvdisplay lvdisplay
  7867.  
  7868. _lvchange()
  7869. {
  7870.     local cur prev
  7871.  
  7872.     COMPREPLY=()
  7873.     cur=`_get_cword`
  7874.     prev=${COMP_WORDS[COMP_CWORD-1]}
  7875.  
  7876.     case "$prev" in
  7877.         -@(a|A|C|M|-available|-autobackup|-continguous|-persistent))
  7878.             COMPREPLY=( $( compgen -W 'y n' -- $cur ) )
  7879.             return 0
  7880.             ;;
  7881.         -@(p|-permission))
  7882.             COMPREPLY=( $( compgen -W 'r rw' -- $cur ) )
  7883.             return 0
  7884.             ;;
  7885.     esac
  7886.  
  7887.     if [[ "$cur" == -* ]]; then
  7888.         COMPREPLY=( $( compgen -W '-A --autobackup -a --available \
  7889.             --addtag --alloc -C --contiguous -d --debug --deltag \
  7890.             -f --force -h --help --ignorelockingfailure -M \
  7891.             --persistent --major major --minor minor -P --partial \
  7892.             -p --permission -r --readahead --refresh -t --test \
  7893.             -v --verbose --version' -- $cur ) )
  7894.     else
  7895.         _logicalvolumes
  7896.     fi
  7897. }
  7898. complete -F _lvchange lvchange
  7899.  
  7900. _lvcreate()
  7901. {
  7902.     local cur prev
  7903.  
  7904.     COMPREPLY=()
  7905.     cur=`_get_cword`
  7906.     prev=${COMP_WORDS[COMP_CWORD-1]}
  7907.  
  7908.     case "$prev" in
  7909.         -@(A|C|M|Z|-autobackup|-continguous|-persistent|-zero))
  7910.             COMPREPLY=( $( compgen -W 'y n' -- $cur ) )
  7911.             return 0
  7912.             ;;
  7913.         -@(L|-size))
  7914.             _sizes
  7915.             return 0
  7916.             ;;
  7917.         -@(p|-permission))
  7918.             COMPREPLY=( $( compgen -W 'r rw' -- $cur ) )
  7919.             return 0
  7920.             ;;
  7921.         -@(n|-name))
  7922.             _logicalvolumes
  7923.             return 0
  7924.             ;;
  7925.     esac
  7926.  
  7927.     if [[ "$cur" == -* ]]; then
  7928.         COMPREPLY=( $( compgen -W '-A --autobackup --addtag --alloc \
  7929.             -C --contiguous -d --debug -h -? --help -i --stripes \
  7930.             -I --stripesize -l --extents -L --size -M --persistent \
  7931.             --major --minor -n --name -p --permission -r \
  7932.             --readahead -t --test --type -v --verbose -Z --zero \
  7933.             --version' -- $cur ) )
  7934.     else
  7935.         _args
  7936.         if [ $args -eq 0 ]; then
  7937.             _volumegroups
  7938.         else
  7939.             _physicalvolumes
  7940.         fi
  7941.     fi
  7942. }
  7943. complete -F _lvcreate lvcreate
  7944.  
  7945. _lvremove()
  7946. {
  7947.     local cur prev
  7948.  
  7949.     COMPREPLY=()
  7950.     cur=`_get_cword`
  7951.     prev=${COMP_WORDS[COMP_CWORD-1]}
  7952.  
  7953.     case "$prev" in
  7954.         -@(A|-autobackup))
  7955.             COMPREPLY=( $( compgen -W 'y n' -- $cur ) )
  7956.             return 0
  7957.             ;;
  7958.     esac
  7959.  
  7960.     if [[ "$cur" == -* ]]; then
  7961.         COMPREPLY=( $( compgen -W '-A --autobackup -d --debug -f \
  7962.             --force -h -?  --help -t --test -v --verbose \
  7963.             --version' -- $cur ) )
  7964.     else
  7965.         _logicalvolumes
  7966.     fi
  7967. }
  7968. complete -F _lvremove lvremove
  7969.  
  7970. _lvrename()
  7971. {
  7972.     local cur prev
  7973.  
  7974.     COMPREPLY=()
  7975.     cur=`_get_cword`
  7976.     prev=${COMP_WORDS[COMP_CWORD-1]}
  7977.  
  7978.     case "$prev" in
  7979.         -@(A|-autobackup))
  7980.             COMPREPLY=( $( compgen -W 'y n' -- $cur ) )
  7981.             return 0
  7982.             ;;
  7983.     esac
  7984.  
  7985.     if [[ "$cur" == -* ]]; then
  7986.         COMPREPLY=( $( compgen -W '-A --autobackup -d --debug -h \
  7987.             -? --help -t --test -v --verbose --version' -- $cur ) )
  7988.     else
  7989.         _logicalvolumes
  7990.     fi
  7991. }
  7992. complete -F _lvrename lvrename
  7993.  
  7994. _lvreduce()
  7995. {
  7996.     local cur prev
  7997.  
  7998.     COMPREPLY=()
  7999.     cur=`_get_cword`
  8000.     prev=${COMP_WORDS[COMP_CWORD-1]}
  8001.  
  8002.     case "$prev" in
  8003.         -@(A|-autobackup))
  8004.             COMPREPLY=( $( compgen -W 'y n' -- $cur ) )
  8005.             return 0
  8006.             ;;
  8007.         -@(L|-size))
  8008.             _sizes
  8009.             return 0
  8010.             ;;
  8011.     esac
  8012.  
  8013.     if [[ "$cur" == -* ]]; then
  8014.         COMPREPLY=( $( compgen -W '-A --autobackup -d \
  8015.             --debug -f --force -h --help -l --extents \
  8016.             -L --size -n --nofsck -r --resizefs -t --test \
  8017.             -v --verbose --version' -- $cur ) )
  8018.     else
  8019.         _logicalvolumes
  8020.     fi
  8021. }
  8022. complete -F _lvreduce lvreduce
  8023.  
  8024. _lvresize()
  8025. {
  8026.     local cur prev
  8027.  
  8028.     COMPREPLY=()
  8029.     cur=`_get_cword`
  8030.     prev=${COMP_WORDS[COMP_CWORD-1]}
  8031.  
  8032.     case "$prev" in
  8033.         -@(A|-autobackup))
  8034.             COMPREPLY=( $( compgen -W 'y n' -- $cur ) )
  8035.             return 0
  8036.             ;;
  8037.         -@(L|-size))
  8038.             _sizes
  8039.             return 0
  8040.             ;;
  8041.     esac
  8042.  
  8043.     if [[ "$cur" == -* ]]; then
  8044.         COMPREPLY=( $( compgen -W '-A --autobackup --alloc -d \
  8045.             --debug -h --help -i --stripes -I --stripesize \
  8046.             -l --extents -L --size -n --nofsck -r --resizefs \
  8047.             -t --test --type -v --verbose --version' -- $cur ) )
  8048.     else
  8049.         _args
  8050.         if [ $args -eq 0 ]; then
  8051.             _logicalvolumes
  8052.         else
  8053.             _physicalvolumes
  8054.         fi
  8055.     fi
  8056. }
  8057. complete -F _lvresize lvresize
  8058.  
  8059. _lvextend()
  8060. {
  8061.     local cur prev
  8062.  
  8063.     COMPREPLY=()
  8064.     cur=`_get_cword`
  8065.     prev=${COMP_WORDS[COMP_CWORD-1]}
  8066.  
  8067.     case "$prev" in
  8068.         -@(A|-autobackup))
  8069.             COMPREPLY=( $( compgen -W 'y n' -- $cur ) )
  8070.             return 0
  8071.             ;;
  8072.         -@(L|-size))
  8073.             _sizes
  8074.             return 0
  8075.             ;;
  8076.     esac
  8077.  
  8078.     if [[ "$cur" == -* ]]; then
  8079.         COMPREPLY=( $( compgen -W '-A --autobackup --alloc -d \
  8080.             --debug -h --help -i --stripes -I --stripesize \
  8081.             -l --extents -L --size -n --nofsck -r --resizefs \
  8082.             -t --test --type -v --verbose --version' -- $cur ) )
  8083.     else
  8084.         _args
  8085.         if [ $args -eq 0 ]; then
  8086.             _logicalvolumes
  8087.         else
  8088.             _physicalvolumes
  8089.         fi
  8090.     fi
  8091. }
  8092. complete -F _lvextend lvextend
  8093.  
  8094. _lvm()
  8095. {
  8096.     local prev
  8097.  
  8098.     COMPREPLY=()
  8099.     cur=`_get_cword`
  8100.  
  8101.     if [ $COMP_CWORD -eq 1 ]; then
  8102.         COMPREPLY=( $( compgen -W 'dumpconfig help lvchange \
  8103.             lvcreate lvdisplay lvextend lvmchange \
  8104.             lvmdiskscan lvmsadc lvmsar lvreduce \
  8105.             lvremove lvrename lvresize lvs lvscan \
  8106.             pvchange pvcreate pvdata pvdisplay pvmove \
  8107.             pvremove pvresize pvs pvscan vgcfgbackup \
  8108.             vgcfgrestore vgchange vgck vgconvert \
  8109.             vgcreate vgdisplay vgexport vgextend \
  8110.             vgimport vgmerge vgmknodes vgreduce \
  8111.             vgremove vgrename vgs vgscan vgsplit \
  8112.             version' -- $cur ) )
  8113.     else
  8114.         case ${COMP_WORDS[1]} in
  8115.             pvchange)
  8116.                 _pvchange
  8117.                 ;;
  8118.             pvcreate)
  8119.                 _pvcreate
  8120.                 ;;
  8121.             pvdisplay)
  8122.                 _pvdisplay
  8123.                 ;;
  8124.             pvmove)
  8125.                 _pvmove
  8126.                 ;;
  8127.             pvremove)
  8128.                 _pvremove
  8129.                 ;;
  8130.             pvresize)
  8131.                 _pvresize
  8132.                 ;;
  8133.             pvs)
  8134.                 _pvs
  8135.                 ;;
  8136.             pvscan)
  8137.                 _pvscan
  8138.                 ;;
  8139.             vgcfgbackup)
  8140.                 _vgcfgbackup
  8141.                 ;;
  8142.             vgcfgrestore)
  8143.                 _vgcfgrestore
  8144.                 ;;
  8145.             vgchange)
  8146.                 _vgchange
  8147.                 ;;
  8148.             vgck)
  8149.                 _vgck
  8150.                 ;;
  8151.             vgconvert)
  8152.                 _vgconvert
  8153.                 ;;
  8154.             vgcreate)
  8155.                 _vgcreate
  8156.                 ;;
  8157.             vgdisplay)
  8158.                 _vgdisplay
  8159.                 ;;
  8160.             vgexport)
  8161.                 _vgexport
  8162.                 ;;
  8163.             vgextend)
  8164.                 _vgextend
  8165.                 ;;
  8166.             vgimport)
  8167.                 _vgimport
  8168.                 ;;
  8169.             vgmerge)
  8170.                 _vgmerge
  8171.                 ;;
  8172.             vgmknodes)
  8173.                 _vgmknodes
  8174.                 ;;
  8175.             vgreduce)
  8176.                 _vgreduce
  8177.                 ;;
  8178.             vgremove)
  8179.                 _vgremove
  8180.                 ;;
  8181.             vgrename)
  8182.                 _vgrename
  8183.                 ;;
  8184.             vgs)
  8185.                 _vgs
  8186.                 ;;
  8187.             vgscan)
  8188.                 _vgscan
  8189.                 ;;
  8190.             vgsplit)
  8191.                 _vgsplit
  8192.                 ;;
  8193.             lvchange)
  8194.                 _lvchange
  8195.                 ;;
  8196.             lvcreate)
  8197.                 _lvcreate
  8198.                 ;;
  8199.             lvdisplay)
  8200.                 _lvdisplay
  8201.                 ;;
  8202.             lvextend)
  8203.                 _lvextend
  8204.                 ;;
  8205.             lvreduce)
  8206.                 _lvreduce
  8207.                 ;;
  8208.             lvremove)
  8209.                 _lvremove
  8210.                 ;;
  8211.             lvrename)
  8212.                 _lvrename
  8213.                 ;;
  8214.             lvresize)
  8215.                 _lvresize
  8216.                 ;;
  8217.             lvs)
  8218.                 _lvs
  8219.                 ;;
  8220.             lvscan)
  8221.                 _lvscan
  8222.                 ;;
  8223.         esac
  8224.     fi
  8225. }
  8226. complete -F _lvm lvm
  8227. }
  8228.  
  8229. # mkinitrd(8) completion
  8230. #
  8231. have mkinitrd &&
  8232. _mkinitrd()
  8233. {
  8234.     local cur args
  8235.  
  8236.     COMPREPLY=()
  8237.     cur=`_get_cword`
  8238.     prev=${COMP_WORDS[COMP_CWORD-1]}
  8239.  
  8240.     # --name value style option
  8241.     case "$prev" in
  8242.         --preload)
  8243.             _modules
  8244.             return 0
  8245.             ;;
  8246.     esac
  8247.  
  8248.     # --name=value style option
  8249.     if [[ "$cur" == *=* ]]; then
  8250.         prev=${cur/=*/}
  8251.         cur=${cur/*=/}
  8252.         case "$prev" in
  8253.             --@(with|builtin))
  8254.                 _modules
  8255.                 return 0
  8256.                 ;;
  8257.             --@(fstab|dsdt))
  8258.                 _filedir
  8259.                 return 0
  8260.                 ;;
  8261.             --tmpdir)
  8262.                 _filedir -d
  8263.                 return 0
  8264.                 ;;
  8265.         esac
  8266.     fi
  8267.  
  8268.  
  8269.     if [[ "$cur" == -* ]]; then
  8270.         COMPREPLY=( $( compgen -W '--version -v -f --preload \
  8271.             --with= --omit-scsi-modules --omit-raid-modules \
  8272.             --images-version --fstab= --nocompress --builtin= \
  8273.             --nopivot --noudev --allow-missing --tmpdir= \
  8274.             --initrdfs= --dsdt= --lvm-version= --froce-usb' \
  8275.             -- $cur ) )
  8276.     else
  8277.         _count_args
  8278.  
  8279.         case $args in
  8280.             1)
  8281.                 _filedir
  8282.                 ;;
  8283.             2)
  8284.                 COMPREPLY=( $( command ls /lib/modules | grep "^$cur" ) )
  8285.                 ;;
  8286.         esac
  8287.     fi
  8288.  
  8289. } &&
  8290. complete -F _mkinitrd mkinitrd
  8291.  
  8292. # pkgconfig(1) completion
  8293. #
  8294. have pkg-config &&
  8295. _pkg_config()
  8296. {
  8297.     local cur
  8298.  
  8299.     COMPREPLY=()
  8300.     cur=`_get_cword`
  8301.  
  8302.     if [[ "$cur" == -* ]]; then
  8303.         # return list of available options
  8304.         COMPREPLY=( $( compgen -W '-version --modversion \
  8305.               --atleast-pkgconfig-version= --libs --libs-only-l \
  8306.               --libs-only-other --libs-only-L --cflags \
  8307.               --cflags-only-I --cflags-only-other --variable= \
  8308.               --define-variable= --exists --uninstalled \
  8309.               --atleast-version= --exact-version= --max-version= \
  8310.               --list-all --debug --print-errors --silence-errors \
  8311.               --errors-to-stdout -? --help --usage' -- $cur))
  8312.     else
  8313.         COMPREPLY=( $( pkg-config --list-all 2>/dev/null | \
  8314.                     awk '{print $1}' | grep "^$cur" ) )
  8315.     fi
  8316. } &&
  8317. complete -F _pkg_config pkg-config
  8318.  
  8319.  
  8320. # cpio(1) completion
  8321. #
  8322. have cpio && {
  8323. _cpio_format()
  8324. {
  8325.     COMPREPLY=( $( compgen -W 'bin odc newc crc tar ustar hpbin hpodc' -- $cur ) )
  8326. }
  8327.  
  8328. _cpio()
  8329. {
  8330.     local cur
  8331.  
  8332.     COMPREPLY=()
  8333.     cur=`_get_cword`
  8334.     prev=${COMP_WORDS[COMP_CWORD-1]}
  8335.  
  8336.     # --name value style option
  8337.     case $prev in
  8338.         -H)
  8339.             _cpio_format
  8340.             return 0
  8341.             ;;
  8342.         -@(E|F|I))
  8343.             _filedir
  8344.             return 0
  8345.             ;;
  8346.         -R)
  8347.             _usergroup
  8348.             return 0
  8349.             ;;
  8350.     esac
  8351.  
  8352.     # --name=value style option
  8353.     if [[ "$cur" == *=* ]]; then
  8354.         prev=${cur/=*/}
  8355.         cur=${cur/*=/}
  8356.         case $prev in
  8357.             --format)
  8358.                 _cpio_format
  8359.                 return 0
  8360.                 ;;
  8361.             --@(file|pattern-file))
  8362.                 _filedir
  8363.                 return 0
  8364.                 ;;
  8365.             --owner)
  8366.                 _usergroup
  8367.                 return 0
  8368.                 ;;
  8369.             --rsh-command)
  8370.                 COMPREPLY=( $( compgen -c -- $cur ) )
  8371.                 return 0
  8372.                 ;;
  8373.         esac
  8374.     fi
  8375.  
  8376.     if [ $COMP_CWORD -eq 1 ]; then
  8377.         COMPREPLY=( $( compgen -W '-o --create -i --extract -p --pass-through' -- $cur) ) 
  8378.     else
  8379.         case ${COMP_WORDS[1]} in
  8380.             -@(o|-create))
  8381.                 if [[ "$cur" == -* ]]; then
  8382.                     COMPREPLY=( $( compgen -W '-0 -a -c -v -A -B\
  8383.                         -L -V -C -H -M -O -F --file= --format=\
  8384.                         --message= --null --reset-access-time\
  8385.                         --verbose --dot --append --block-size=\
  8386.                         --dereference --io-size= --quiet\
  8387.                         --force-local --rsh-command= --help\
  8388.                         --version' -- $cur ) )
  8389.                 fi
  8390.                 ;;
  8391.             -@(i|-extract))
  8392.                 if [[ "$cur" == -* ]]; then
  8393.                     COMPREPLY=( $( compgen -W '-b -c -d -f -m -n -r\
  8394.                         -t -s -u -v -B -S -V -C -E -H -M -R -I\
  8395.                         -F --file= --make-directories\
  8396.                         --nonmatching\
  8397.                         --preserve-modification-time\
  8398.                         --numeric-uid-gid --rename -t --list\
  8399.                         --swap-bytes --swap --dot\
  8400.                         --unconditional --verbose --block-size=\
  8401.                         --swap-halfwords --io-size=\
  8402.                         --pattern-file= --format= --owner=\
  8403.                         --no-preserve-owner --message=\
  8404.                         --force-local --no-absolute-filenames\
  8405.                         --sparse --only-verify-crc --quiet\
  8406.                         --rsh-command= --help\
  8407.                         --version' -- $cur ) )
  8408.                 fi
  8409.                 ;;
  8410.             -@(p|-pass-through))
  8411.                 if [[ "$cur" == -* ]]; then
  8412.                     COMPREPLY=( $( compgen -W '-0 -a -d -l -m -u -v\
  8413.                         -L -V -R --null --reset-access-time\
  8414.                         --make-directories --link --quiet\
  8415.                         --preserve-modification-time\
  8416.                         --unconditional --verbose --dot\
  8417.                         --dereference --owner=\
  8418.                         --no-preserve-owner --sparse --help\
  8419.                         --version' -- $cur ) )
  8420.                 else
  8421.                     _filedir -d
  8422.                 fi
  8423.                 ;;
  8424.         esac
  8425.     fi
  8426. }
  8427. complete -F _cpio cpio
  8428. }
  8429.  
  8430. # id(1) completion
  8431. #
  8432. have id &&
  8433. _id()
  8434. {
  8435.     local cur
  8436.  
  8437.     COMPREPLY=()
  8438.     cur=`_get_cword`
  8439.  
  8440.     if [[ "$cur" == -* ]]; then
  8441.         COMPREPLY=( $( compgen -W '-a -g --group -G --groups -n --name\
  8442.             -r --real -u --user --help --version' -- $cur ) )
  8443.     else
  8444.         COMPREPLY=( $( compgen -u $cur  ) )
  8445.     fi
  8446. } &&
  8447. complete -F _id id
  8448.  
  8449. # getent(1) completion
  8450. #
  8451. have getent &&
  8452. _getent()
  8453. {
  8454.     local cur prev
  8455.  
  8456.     COMPREPLY=()
  8457.     cur=`_get_cword`
  8458.     prev=${COMP_WORDS[COMP_CWORD-1]}
  8459.  
  8460.     case $prev in
  8461.         passwd)
  8462.             COMPREPLY=( $( compgen -u $cur  ) )
  8463.             return 0
  8464.             ;;
  8465.         group)
  8466.             COMPREPLY=( $( compgen -g $cur  ) )
  8467.             return 0
  8468.             ;;
  8469.         services)
  8470.             COMPREPLY=( $( compgen -s $cur  ) )
  8471.             return 0
  8472.             ;;
  8473.         hosts)
  8474.             COMPREPLY=( $( compgen -A hostname $cur  ) )
  8475.             return 0
  8476.             ;;
  8477.         protocols)
  8478.             COMPREPLY=( $( getent protocols | awk '{print $1}' | grep "^$cur" ) )
  8479.             return 0
  8480.             ;;
  8481.         networks)
  8482.             COMPREPLY=( $( getent networks | awk '{print $1}' | grep "^$cur" ) )
  8483.             return 0
  8484.             ;;
  8485.     esac
  8486.  
  8487.  
  8488.     if [ $COMP_CWORD -eq 1 ]; then
  8489.         COMPREPLY=( $( compgen -W 'passwd group hosts services protocols networks' -- $cur ) )
  8490.     fi
  8491. } &&
  8492. complete -F _getent getent
  8493.  
  8494. # ntpdate(1) completion
  8495. #
  8496. have ntpdate &&
  8497. _ntpdate()
  8498. {
  8499.     local cur prev
  8500.  
  8501.     COMPREPLY=()
  8502.     cur=`_get_cword`
  8503.     prev=${COMP_WORDS[COMP_CWORD-1]}
  8504.  
  8505.     case $prev in
  8506.         -k)
  8507.             _filedir
  8508.             return 0
  8509.             ;;
  8510.         -U)
  8511.             COMPREPLY=( $( compgen -u $cur  ) )
  8512.             return 0
  8513.             ;;
  8514.     esac
  8515.  
  8516.     if [[ "$cur" == -* ]]; then
  8517.         COMPREPLY=( $( compgen -W '-4 -6 -b -B -d -Q -q -s -u -v -a\
  8518.             -e -k -p -o -r -t' -- $cur ) )
  8519.     else
  8520.         _known_hosts
  8521.     fi
  8522. } &&
  8523. complete -F _ntpdate ntpdate
  8524.  
  8525. # smartctl(8) completion
  8526. #
  8527. have smartctl && {
  8528. _smartctl_quietmode()
  8529. {
  8530.     COMPREPLY=( $( compgen -W 'errorsonly silent' -- $cur ) )
  8531. }
  8532. _smartctl_device()
  8533. {
  8534.     COMPREPLY=( $( compgen -W 'ata scsi 3ware' -- $cur ) )
  8535. }
  8536. _smartctl_tolerance()
  8537. {
  8538.     COMPREPLY=( $( compgen -W 'warn exit ignore' -- $cur ) )
  8539. }
  8540. _smartctl_badsum()
  8541. {
  8542.     COMPREPLY=( $( compgen -W 'normal conservative permissive verypermissive' -- $cur ) )
  8543. }
  8544. _smartctl_report()
  8545. {
  8546.     COMPREPLY=( $( compgen -W 'ioctl ataioctl scsiioctl' -- $cur ) )
  8547. }
  8548. _smartctl_feature()
  8549. {
  8550.     COMPREPLY=( $( compgen -W 'on off' -- $cur ) )
  8551. }
  8552. _smartctl_log()
  8553. {
  8554.     COMPREPLY=( $( compgen -W 'error selftest selective directory' -- $cur ) )
  8555. }
  8556. _smartctl_vendorattribute()
  8557. {
  8558.     COMPREPLY=( $( compgen -W 'help 9,minutes 9,seconds 9,halfminutes \
  8559.         9,temp 192,emergencyretractcyclect 193,loadunload \
  8560.         194,10xCelsius 194,unknown 198,offlinescanuncsectorct \
  8561.         200,writeerrorcount 201,detectedtacount 220,temp' -- $cur ) )
  8562. }
  8563. _smartctl_firmwarebug()
  8564. {
  8565.     COMPREPLY=( $( compgen -W 'none samsung samsung2' -- $cur ) )
  8566. }
  8567. _smartctl_presets()
  8568. {
  8569.     COMPREPLY=( $( compgen -W 'use ignore show showall' -- $cur ) )
  8570. }
  8571. _smartctl_test()
  8572. {
  8573.     COMPREPLY=( $( compgen -W 'offline short long conveyance select afterselect,on afterselect,off pending' -- $cur ) )
  8574. }
  8575.  
  8576. _smartctl()
  8577. {
  8578.     local cur prev
  8579.  
  8580.     COMPREPLY=()
  8581.     cur=`_get_cword`
  8582.     prev=${COMP_WORDS[COMP_CWORD-1]}
  8583.  
  8584.     # --name value style option
  8585.     case "$prev" in
  8586.         -q)
  8587.             _smartctl_quietmode
  8588.             ;;
  8589.         -d)
  8590.             _smartctl_device
  8591.             return 0
  8592.             ;;
  8593.         -t)
  8594.             _smartctl_tolerance
  8595.             return 0
  8596.             ;;
  8597.         -b)
  8598.             _smartctl_badsum
  8599.             return 0
  8600.             ;;
  8601.         -r)
  8602.             _smartctl_report
  8603.             return 0
  8604.             ;;
  8605.         -s)
  8606.             _smartctl_feature
  8607.             return 0
  8608.             ;;
  8609.         -o)
  8610.             _smartctl_feature
  8611.             return 0
  8612.             ;;
  8613.         -S)
  8614.             _smartctl_feature
  8615.             return 0
  8616.             ;;
  8617.         -l)
  8618.             _smartctl_log
  8619.             return 0
  8620.             ;;
  8621.         -v)
  8622.             _smartctl_vendorattribute
  8623.             return 0
  8624.             ;;
  8625.         -F)
  8626.             _smartctl_firmwarebug
  8627.             return 0
  8628.             ;;
  8629.         -P)
  8630.             _smartctl_presets
  8631.             return 0
  8632.             ;;
  8633.         -t)
  8634.             _smartctl_test
  8635.             return 0
  8636.             ;;
  8637.     esac
  8638.  
  8639.     # --name=value style option
  8640.     if [[ "$cur" == *=* ]]; then
  8641.         prev=${cur/=*/}
  8642.         cur=${cur/*=/}
  8643.         case "$prev" in
  8644.             --quietmode)
  8645.                 _smartctl_quietmode
  8646.                 return 0
  8647.                 ;;
  8648.             --device)
  8649.                 _smartctl_device
  8650.                 return 0
  8651.                 ;;
  8652.             --tolerance)
  8653.                 _smartctl_tolerance
  8654.                 return 0
  8655.                 ;;
  8656.             --badsum)
  8657.                 _smartctl_badsum
  8658.                 return 0
  8659.                 ;;
  8660.             --report)
  8661.                 _smartctl_report
  8662.                 return 0
  8663.                 ;;
  8664.             --smart)
  8665.                 _smartctl_feature
  8666.                 return 0
  8667.                 ;;
  8668.             --offlineauto)
  8669.                 _smartctl_feature
  8670.                 return 0
  8671.                 ;;
  8672.             --saveauto)
  8673.                 _smartctl_feature
  8674.                 return 0
  8675.                 ;;
  8676.             --log)
  8677.                 _smartctl_log
  8678.                 return 0
  8679.                 ;;
  8680.             --vendorattribute)
  8681.                 _smartctl_vendorattribute
  8682.                 return 0
  8683.                 ;;
  8684.             --firmwarebug)
  8685.                 _smartctl_firmwarebug
  8686.                 return 0
  8687.                 ;;
  8688.             --presets)
  8689.                 _smartctl_presets
  8690.                 return 0
  8691.                 ;;
  8692.             --test)
  8693.                 _smartctl_test
  8694.                 return 0
  8695.                 ;;
  8696.         esac
  8697.     fi
  8698.  
  8699.  
  8700.     if [[ "$cur" == -* ]]; then
  8701.         COMPREPLY=( $( compgen -W '-h --help --usage -V --version \
  8702.             --copyright --license-i --info -a --all -q \
  8703.             --quietmode= -d --device= -T --tolerance= -b --badsum= \
  8704.             -r --report= -s --smart= -o --offlineauto= -S \
  8705.             --saveauto= -H --health -c --capabilities -A \
  8706.             --attributes -l --log= -v --vendorattribute= -F \
  8707.             --firmwarebug= -P --presets= -t --test= -C \
  8708.             --captive -X --abort' -- $cur ) )
  8709.     else
  8710.         cur=${cur:=/dev/}
  8711.         _filedir
  8712.     fi
  8713. }
  8714. complete -F _smartctl smartctl
  8715. }
  8716.  
  8717. # vncviewer(1) completion
  8718. #
  8719. have vncviewer &&
  8720. _vncviewer()
  8721. {
  8722.     local cur prev
  8723.     local -a config
  8724.     
  8725.     COMPREPLY=()
  8726.     cur=`_get_cword`
  8727.     prev=${COMP_WORDS[COMP_CWORD-1]}
  8728.  
  8729.     case "$prev" in
  8730.     -via)
  8731.        _known_hosts -a
  8732.        ;;
  8733.     *)
  8734.        # ssh into the the server, find and ping the broadcast address, then
  8735.        # sort and show the results.
  8736.        COMPREPLY=( $( ssh -o 'Batchmode yes' $prev \
  8737.               "ping -bnc 4 255.255.255.255" 2>/dev/null | \
  8738.               awk -F ' ' '{print $4}' | \
  8739.               sort -n | uniq | egrep '[0-9]+\.[0-9]+\.' 2>/dev/null ) )
  8740.     esac
  8741.                                    
  8742.     return 0
  8743. } &&
  8744. complete -F _vncviewer vncviewer
  8745.  
  8746. # sysctl(8) completion
  8747. #
  8748. have sysctl &&
  8749. _sysctl()
  8750. {
  8751.     local cur
  8752.  
  8753.     COMPREPLY=()
  8754.     cur=`_get_cword`
  8755.  
  8756.     COMPREPLY=( $( compgen -W "$(sysctl -N -a 2>/dev/null)" -- $cur ) )
  8757.  
  8758.     return 0
  8759. } &&
  8760. complete -F _sysctl sysctl
  8761.  
  8762. # update-rc.d(8) completion
  8763. #
  8764. # Copyright (C) 2004 Servilio Afre Puentes <servilio@gmail.com>
  8765. #
  8766. have update-rc.d &&
  8767. _update_rc_d()
  8768. {
  8769.     local cur prev sysvdir services options valid_options
  8770.  
  8771.     cur=`_get_cword`
  8772.     prev=${COMP_WORDS[COMP_CWORD-1]}
  8773.  
  8774.     [ -d /etc/rc.d/init.d ] && sysvdir=/etc/rc.d/init.d \
  8775.     || sysvdir=/etc/init.d
  8776.  
  8777.     services=( $(echo $sysvdir/!(README*|*.sh|*.dpkg*|*.rpm*)) )
  8778.     services=( ${services[@]#$sysvdir/} )
  8779.     options=( -f -n )
  8780.  
  8781.     if [[ $COMP_CWORD -eq 1 || "$prev" == -* ]]; then
  8782.     valid_options=( $( \
  8783.         echo "${COMP_WORDS[@]} ${options[@]}" \
  8784.         | tr " " "\n" \
  8785.         | sed -ne "/$( echo "${options[@]}" | sed "s/ /\\|/g" )/p" \
  8786.         | sort | uniq -u \
  8787.         ) )
  8788.     COMPREPLY=( $( compgen -W '${options[@]} ${services[@]}' \
  8789.         -X '$( echo ${COMP_WORDS[@]} | tr " " "|" )' -- $cur ) )
  8790.     elif [[ "$prev" == ?($( echo ${services[@]} | tr " " "|" )) ]]; then
  8791.     COMPREPLY=( $( compgen -W 'remove defaults start stop' -- $cur ) )
  8792.     elif [[ "$prev" == defaults && "$cur" == [0-9] ]]; then
  8793.     COMPREPLY=( 0 1 2 3 4 5 6 7 8 9 )
  8794.     elif [[ "$prev" == defaults && "$cur" == [sk]?([0-9]) ]]; then
  8795.     COMPREPLY=( 0 1 2 3 4 5 6 7 8 9 )
  8796.     elif [[ "$prev" == defaults && -z "$cur" ]]; then
  8797.     COMPREPLY=( 0 1 2 3 4 5 6 7 8 9 s k )
  8798.     elif [[ "$prev" == ?(start|stop) ]]; then
  8799.     if [[ "$cur" == [0-9] || -z "$cur" ]]; then 
  8800.         COMPREPLY=( 0 1 2 3 4 5 6 7 8 9 )
  8801.     elif [[ "$cur" == [0-9][0-9] ]]; then 
  8802.         COMPREPLY=( $cur )
  8803.     else
  8804.         COMPREPLY=()
  8805.     fi
  8806.     elif [[ "$prev" == ?([0-9][0-9]|[0-6S]) ]]; then
  8807.     if [[ -z "$cur" ]]; then
  8808.         if [[ $prev == [0-9][0-9] ]]; then
  8809.         COMPREPLY=( 0 1 2 3 4 5 6 S )
  8810.         else
  8811.         COMPREPLY=( 0 1 2 3 4 5 6 S . )
  8812.         fi
  8813.     elif [[ "$cur" == [0-6S.] ]]; then 
  8814.         COMPREPLY=( $cur )
  8815.     else
  8816.         COMPREPLY=()
  8817.     fi
  8818.     elif [[ "$prev" == "." ]]; then
  8819.     COMPREPLY=( $(compgen -W "start stop" -- $cur) )
  8820.     else
  8821.     COMPREPLY=()
  8822.     fi
  8823.  
  8824.     return 0
  8825. } &&
  8826. complete -F _update_rc_d update-rc.d
  8827.  
  8828. # invoke-rc.d(8) completion
  8829. #
  8830. # Copyright (C) 2004 Servilio Afre Puentes <servilio@gmail.com>
  8831. #
  8832. have invoke-rc.d &&
  8833. _invoke_rc_d()
  8834. {
  8835.     local cur prev sysvdir services options valid_options
  8836.  
  8837.     cur=`_get_cword`
  8838.     prev=${COMP_WORDS[COMP_CWORD-1]}
  8839.  
  8840.     [ -d /etc/rc.d/init.d ] && sysvdir=/etc/rc.d/init.d \
  8841.     || sysvdir=/etc/init.d
  8842.  
  8843.     services=( $(echo $sysvdir/!(README*|*.sh|*.dpkg*|*.rpm*)) )
  8844.     services=( ${services[@]#$sysvdir/} )
  8845.     options=( --help --quiet --force --try-anyway --disclose-deny --query --no-fallback )
  8846.  
  8847.     if [[ ($COMP_CWORD -eq 1) || ("$prev" == --* ) ]]; then
  8848.     valid_options=( $( \
  8849.         echo ${COMP_WORDS[@]} ${options[@]} \
  8850.         | tr " " "\n" \
  8851.         | sed -ne "/$( echo ${options[@]} | sed "s/ /\\\\|/g" )/p" \
  8852.         | sort | uniq -u \
  8853.         ) )
  8854.     COMPREPLY=( $( compgen -W '${valid_options[@]} ${services[@]}' -- \
  8855.         $cur ) )
  8856.     elif [ -x $sysvdir/$prev ]; then
  8857.     COMPREPLY=( $( compgen -W '`sed -ne "y/|/ /; \
  8858.                         s/^.*Usage:[ ]*[^ ]*[ ]*{*\([^}\"]*\).*$/\1/p" \
  8859.                         $sysvdir/$prev`' -- \
  8860.         $cur ) )
  8861.     else
  8862.     COMPREPLY=()
  8863.     fi
  8864.  
  8865.     return 0
  8866. } &&
  8867. complete -F _invoke_rc_d invoke-rc.d
  8868.  
  8869. # minicom(1) completion
  8870. #
  8871. have minicom &&
  8872. _minicom()
  8873. {
  8874.     local cur prev
  8875.  
  8876.     COMPREPLY=()
  8877.     cur=`_get_cword`
  8878.     prev=${COMP_WORDS[COMP_CWORD-1]}
  8879.  
  8880.     case $prev in
  8881.         -@(a|c))
  8882.             COMPREPLY=( $( compgen -W 'on off' -- $cur ) )
  8883.             return 0
  8884.             ;;
  8885.         -@(S|C))
  8886.             _filedir
  8887.             return 0
  8888.             ;;
  8889.         -P)
  8890.             COMPREPLY=( $( command ls /dev/tty* ) )
  8891.             COMPREPLY=( $( compgen -W '${COMPREPLY[@]} ${COMPREPLY[@]#/dev/}' -- $cur ) )
  8892.             return 0
  8893.             ;;
  8894.     esac
  8895.  
  8896.  
  8897.     if [[ "$cur" == -* ]]; then
  8898.         COMPREPLY=( $( compgen -W '-s -o -m -M -z -l -L -w -a -t \
  8899.             -c -S -d -p -C -T -8' -- $cur ) )
  8900.     else
  8901.         COMPREPLY=( $( command ls /etc/minicom/minirc.* 2>/dev/null | sed -e 's|/etc/minicom/minirc.||' | grep "^$cur" ) )
  8902.     fi
  8903. } &&
  8904. complete -F _minicom minicom
  8905.  
  8906. # svn completion
  8907. #
  8908. have svn &&
  8909. {
  8910. _svn()
  8911. {
  8912.     local cur prev commands options command
  8913.  
  8914.     COMPREPLY=()
  8915.     cur=`_get_cword`
  8916.  
  8917.     commands='add blame praise annotate ann cat checkout co cleanup commit \
  8918.         ci copy cp delete del remove rm diff di export help ? h import \
  8919.         info list ls lock log merge mkdir move mv rename ren \
  8920.         propdel pdel pd propedit pedit pe propget pget pg \
  8921.         proplist plist pl propset pset ps resolved revert \
  8922.         status stat st switch sw unlock update up'
  8923.  
  8924.     if [[ $COMP_CWORD -eq 1 ]] ; then
  8925.         if [[ "$cur" == -* ]]; then
  8926.             COMPREPLY=( $( compgen -W '--version' -- $cur ) )
  8927.         else
  8928.             COMPREPLY=( $( compgen -W "$commands" -- $cur ) )
  8929.         fi
  8930.     else
  8931.  
  8932.         prev=${COMP_WORDS[COMP_CWORD-1]}
  8933.         case $prev in
  8934.             --config-dir)
  8935.                 _filedir -d
  8936.                 return 0;
  8937.                 ;;
  8938.             -@(F|-file|-targets))
  8939.                 _filedir
  8940.                 return 0;
  8941.                 ;;
  8942.             --encoding)
  8943.                 COMPREPLY=( $( compgen -W \
  8944.                     '$( iconv --list | sed -e "s@//@@;" )' \
  8945.                     -- "$cur" ) )
  8946.                 return 0;
  8947.                 ;;
  8948.             --@(editor|diff|diff3)-cmd)
  8949.                 COMP_WORDS=(COMP_WORDS[0] $cur)
  8950.                 COMP_CWORD=1
  8951.                 _command
  8952.                 return 0;
  8953.                 ;;
  8954.         esac
  8955.  
  8956.         command=${COMP_WORDS[1]}
  8957.  
  8958.         if [[ "$cur" == -* ]]; then
  8959.             # possible options for the command
  8960.             case $command in
  8961.                 add)
  8962.                     options='--auto-props --no-auto-props \
  8963.                         --force --targets --no-ignore \
  8964.                         --non-recursive -N -q --quiet'
  8965.                     ;;
  8966.                 @(blame|annotate|ann|praise))
  8967.                     options='-r --revisions --username \
  8968.                         --password --no-auth-cache \
  8969.                         --non-interactive -v \
  8970.                         --verbose --incremental --xml'
  8971.                     ;;
  8972.                 cat)
  8973.                     options='-r --revision --username \
  8974.                         --password --no-auth-cache \
  8975.                         --non-interactive'
  8976.                     ;;
  8977.                 @(checkout|co))
  8978.                     options='-r --revision -q --quiet -N \
  8979.                         --non-recursive --username \
  8980.                         --password --no-auth-cache \
  8981.                         --non-interactive \
  8982.                         --ignore-externals'
  8983.                     ;;
  8984.                 cleanup)
  8985.                     options='--diff3-cmd'
  8986.                     ;;
  8987.                 @(commit|ci))
  8988.                     options='-m --message -F --file \
  8989.                         --encoding --force-log -q \
  8990.                         --quiet --non-recursive -N \
  8991.                         --targets --editor-cmd \
  8992.                         --username --password \
  8993.                         --no-auth-cache \
  8994.                         --non-interactive --no-unlock'
  8995.                     ;;
  8996.                 @(copy|cp))
  8997.                     options='-m --message -F --file \
  8998.                         --encoding --force-log -r \
  8999.                         --revision -q --quiet \
  9000.                         --editor-cmd -username \
  9001.                         --password --no-auth-cache \
  9002.                         --non-interactive'
  9003.                     ;;
  9004.                 @(delete|del|remove|rm))
  9005.                     options='--force -m --message -F \
  9006.                         --file --encoding --force-log \
  9007.                         -q --quiet --targets \
  9008.                         --editor-cmd -username \
  9009.                         --password --no-auth-cache \
  9010.                         --non-interactive'
  9011.                     ;;
  9012.                 @(diff|di))
  9013.                     options='-r --revision -x --extensions \
  9014.                         --diff-cmd --no-diff-deleted \
  9015.                         -N --non-recursive --username \
  9016.                         --password --no-auth-cache \
  9017.                         --non-interactive --force \
  9018.                         --old --new --notice-ancestry'
  9019.                     ;;
  9020.                 export)
  9021.                     options='-r --revision -q --quiet \
  9022.                         --username --password \
  9023.                         --no-auth-cache \
  9024.                         --non-interactive -N \
  9025.                         --non-recursive --force \
  9026.                         --native-eol --ignore-externals'
  9027.                     ;;
  9028.                 import)
  9029.                     options='--auto-props --no-auto-props \
  9030.                         -m --message -F --file \
  9031.                         --encoding --force-log -q \
  9032.                         --quiet --non-recursive \
  9033.                         --no-ignore --editor-cmd \
  9034.                         --username --password \
  9035.                         --no-auth-cache \
  9036.                         --non-interactive'
  9037.                     ;; 
  9038.                 info)
  9039.                     options='--username --password \
  9040.                         --no-auth-cache \
  9041.                         --non-interactive -r \
  9042.                         --revision --xml --targets \
  9043.                         -R --recursive --incremental'
  9044.                     ;;
  9045.                 @(list|ls))
  9046.                     options='-r --revision -v --verbose -R \
  9047.                         --recursive --username \
  9048.                         --password --no-auth-cache \
  9049.                         --non-interactive \
  9050.                         --incremental --xml'
  9051.                     ;;
  9052.                 lock)
  9053.                     options='-m --message -F --file \
  9054.                         --encoding --force-log \
  9055.                         --targets --force --username \
  9056.                         --password --no-auth-cache \
  9057.                         --non-interactive'
  9058.                     ;;
  9059.                 log)
  9060.                     options='-r --revision -v --verbose \
  9061.                         --targets --username \
  9062.                         --password --no-auth-cache \
  9063.                         --non-interactive \
  9064.                         --stop-on-copy --incremental \
  9065.                         --xml -q --quiet --limit'
  9066.                     ;;
  9067.                 merge)
  9068.                     options='-r --revision -N \
  9069.                         --non-recursive -q --quiet \
  9070.                         --force --dry-run --diff3-cmd \
  9071.                         --username --password \
  9072.                         --no-auth-cache \
  9073.                         --non-interactive \
  9074.                         --ignore-ancestry'
  9075.                     ;;
  9076.                 mkdir)
  9077.                     options='-m --message -F --file \
  9078.                         --encoding --force-log -q \
  9079.                         --quiet --editor-cmd \
  9080.                         --username --password \
  9081.                         --no-auth-cache \
  9082.                         --non-interactive'
  9083.                     ;;
  9084.                 @(move|mv|rename|ren))
  9085.                     options='-m --message -F --file \
  9086.                         --encoding --force-log -r \
  9087.                         --revision -q --quiet \
  9088.                         --force --editor-cmd \
  9089.                         --username --password \
  9090.                         --no-auth-cache \
  9091.                         --non-interactive'
  9092.                     ;;
  9093.                 @(propdel|pdel|pd))
  9094.                     options='-q --quiet -R --recursive -r \
  9095.                         --revision --revprop \
  9096.                         --username --password \
  9097.                         --no-auth-cache \
  9098.                         --non-interactive'
  9099.                     ;;
  9100.                 @(propedit|pedit|pe))
  9101.                     options='-r --revision --revprop \
  9102.                         --encoding --editor-cmd \
  9103.                         --username --password \
  9104.                         --no-auth-cache \
  9105.                         --non-interactive --force'
  9106.                     ;;
  9107.                 @(propget|pget|pg))
  9108.                     options='-R --recursive -r --revision \
  9109.                         --revprop --strict --username \
  9110.                         --password --no-auth-cache \
  9111.                         --non-interactive'
  9112.                     ;;
  9113.                 @(proplist|plist|pl))
  9114.                     options='-v --verbose -R --recursive \
  9115.                         -r --revision --revprop -q \
  9116.                         --quiet --username --password \
  9117.                         --no-auth-cache \
  9118.                         --non-interactive'
  9119.                     ;;
  9120.                 @(propset|pset|ps))
  9121.                     options='-F --file -q --quiet \
  9122.                         --targets -R --recursive \
  9123.                         --revprop --encoding \
  9124.                         --username --password \
  9125.                         --no-auth-cache \
  9126.                         --non-interactive -r \
  9127.                         --revision --force'
  9128.                     ;;
  9129.                 resolved)
  9130.                     options='--targets -R --recursive -q \
  9131.                         --quiet'
  9132.                     ;;
  9133.                 revert)
  9134.                     options='--targets -R --recursive -q \
  9135.                         --quiet'
  9136.                     ;;
  9137.                 @(status|stat|st))
  9138.                     options='-u --show-updates -v \
  9139.                         --verbose -N --non-recursive \
  9140.                         -q --quiet --username \
  9141.                         --password --no-auth-cache \
  9142.                         --non-interactive --no-ignore \
  9143.                         --ignore-externals \
  9144.                         --incremental --xml'
  9145.                     ;;
  9146.                 @(switch|sw))
  9147.                     options='--relocate -r --revision -N \
  9148.                         --non-recursive -q --quiet \
  9149.                         --username --password \
  9150.                         --no-auth-cache \
  9151.                         --non-interactive --diff3-cmd'
  9152.                     ;;
  9153.                 unlock)
  9154.                     options='--targets --force --username \
  9155.                         --password --no-auth-cache \
  9156.                         --non-interactive'
  9157.                     ;;
  9158.                 @(update|up))
  9159.                     options='-r --revision -N \
  9160.                         --non-recursive -q --quiet \
  9161.                         --username --password \
  9162.                         --no-auth-cache \
  9163.                         --non-interactive \
  9164.                         --diff3-cmd --ignore-externals'
  9165.                     ;;
  9166.             esac
  9167.             options="$options --help -h --config-dir"
  9168.  
  9169.             COMPREPLY=( $( compgen -W "$options" -- $cur ) )
  9170.         else
  9171.             if [[ "$command" == @(help|h|\?) ]]; then
  9172.                 COMPREPLY=( $( compgen -W "$commands" -- $cur ) )
  9173.             else
  9174.                 _filedir
  9175.             fi
  9176.         fi
  9177.     fi
  9178.  
  9179.     return 0
  9180. }
  9181. complete -F _svn $default svn
  9182.  
  9183. _svnadmin()
  9184. {
  9185.     local cur prev commands options mode
  9186.  
  9187.     COMPREPLY=()
  9188.     cur=`_get_cword`
  9189.  
  9190.     commands='create deltify dump help ? hotcopy list-dblogs \
  9191.         list-unused-dblogs load lslocks lstxns recover rmlocks \
  9192.         rmtxns setlog verify'
  9193.  
  9194.     if [[ $COMP_CWORD -eq 1 ]] ; then
  9195.         if [[ "$cur" == -* ]]; then
  9196.             COMPREPLY=( $( compgen -W '--version' -- $cur ) )
  9197.         else
  9198.             COMPREPLY=( $( compgen -W "$commands" -- $cur ) )
  9199.         fi
  9200.     else
  9201.         prev=${COMP_WORDS[COMP_CWORD-1]}
  9202.         case $prev in
  9203.             --config-dir)
  9204.                 _filedir -d
  9205.                 return 0;
  9206.                 ;;
  9207.             --fs-type)
  9208.                 COMPREPLY=( $( compgen -W 'fsfs bdb' -- $cur ) )
  9209.                 return 0;
  9210.                 ;;
  9211.         esac
  9212.  
  9213.         command=${COMP_WORDS[1]}
  9214.  
  9215.         if [[ "$cur" == -* ]]; then
  9216.             # possible options for the command
  9217.             case $command in
  9218.                 create)
  9219.                     options='--bdb-txn-nosync \
  9220.                         --bdb-log-keep --config-dir \
  9221.                         --fs-type'
  9222.                     ;;
  9223.                 deltify)
  9224.                     options='-r --revision -q --quiet'
  9225.                     ;;
  9226.                 dump)
  9227.                     options='-r --revision --incremental \
  9228.                         -q --quiet --deltas'
  9229.                     ;;
  9230.                 hotcopy)
  9231.                     options='--clean-logs'
  9232.                     ;;
  9233.                 load)
  9234.                     options='--ignore-uuid --force-uuid \
  9235.                         --parent-dir -q --quiet \
  9236.                         --use-pre-commit-hook \
  9237.                         --use-post-commit-hook'
  9238.                     ;;
  9239.                 rmtxns)
  9240.                     options='-q --quiet'
  9241.                     ;;
  9242.                 setlog)
  9243.                     options='-r --revision --bypass-hooks'
  9244.                     ;;
  9245.             esac
  9246.  
  9247.             options="$options --help -h"
  9248.             COMPREPLY=( $( compgen -W "$options" -- $cur ) )
  9249.         else
  9250.             if [[ "$command" == @(help|h|\?) ]]; then
  9251.                 COMPREPLY=( $( compgen -W "$commands" -- $cur ) )
  9252.             else
  9253.                 _filedir
  9254.             fi
  9255.         fi
  9256.     fi
  9257.  
  9258.     return 0
  9259. }
  9260. complete -F _svnadmin $default svnadmin
  9261.  
  9262. _svnlook()
  9263. {
  9264.     local cur prev commands options mode
  9265.  
  9266.     COMPREPLY=()
  9267.     cur=`_get_cword`
  9268.  
  9269.     commands='author cat changed date diff dirs-changed help ? h history \
  9270.         info lock log propget pget pg proplist plist pl tree uuid \
  9271.         youngest'
  9272.  
  9273.     if [[ $COMP_CWORD -eq 1 ]] ; then
  9274.         if [[ "$cur" == -* ]]; then
  9275.             COMPREPLY=( $( compgen -W '--version' -- $cur ) )
  9276.         else
  9277.             COMPREPLY=( $( compgen -W "$commands" -- $cur ) )
  9278.         fi
  9279.     else
  9280.         command=${COMP_WORDS[1]}
  9281.  
  9282.         if [[ "$cur" == -* ]]; then
  9283.             # possible options for the command
  9284.             case $command in
  9285.                 @(author|cat|date|dirs-changed|info|log))
  9286.                     options='-r --revision -t \
  9287.                         --transaction'
  9288.                     ;;
  9289.                 changed)
  9290.                     options='-r --revision -t \
  9291.                         --transaction --copy-info'
  9292.                     ;;
  9293.                 diff)
  9294.                     options='-r --revision -t \
  9295.                         --transaction \
  9296.                         --no-diff-deleted \
  9297.                         --no-diff-added \
  9298.                         --diff-copy-from'
  9299.                     ;;
  9300.                 history)
  9301.                     options='-r --revision --show-ids'
  9302.                     ;;
  9303.                 prop@(get|list))
  9304.                     options='-r --revision -t \
  9305.                         --transaction --revprop'
  9306.                     ;;
  9307.                 tree)
  9308.                     options='-r --revision -t \
  9309.                         --transaction --show-ids \
  9310.                         --full-paths'
  9311.                     ;;
  9312.             esac
  9313.  
  9314.             options="$options --help -h"
  9315.             COMPREPLY=( $( compgen -W "$options" -- $cur ) )
  9316.         else
  9317.             if [[ "$command" == @(help|h|\?) ]]; then
  9318.                 COMPREPLY=( $( compgen -W "$commands" -- $cur ) )
  9319.             else
  9320.                 _filedir
  9321.             fi
  9322.         fi
  9323.     fi
  9324.  
  9325.     return 0
  9326. }
  9327. complete -F _svnlook $default svnlook
  9328. }
  9329.  
  9330. _filedir_xspec()
  9331. {
  9332.     local IFS cur xspec
  9333.  
  9334.     IFS=$'\t\n'
  9335.     COMPREPLY=()
  9336.     cur=`_get_cword`
  9337.  
  9338.     _expand || return 0
  9339.  
  9340.     # get first exclusion compspec that matches this command
  9341.     xspec=$( sed -ne $'/^complete .*[ \t]'${1##*/}$'\([ \t]\|$\)/{p;q;}' \
  9342.           $BASH_COMPLETION )
  9343.     # prune to leave nothing but the -X spec
  9344.     xspec=${xspec#*-X }
  9345.     xspec=${xspec%% *}
  9346.  
  9347.     local toks=( ) tmp
  9348.  
  9349.     while read -r tmp; do
  9350.         [[ -n $tmp ]] && toks[${#toks[@]}]=$tmp
  9351.     done < <( compgen -d -- "$(quote_readline "$cur")" )
  9352.  
  9353.     while read -r tmp; do
  9354.         [[ -n $tmp ]] && toks[${#toks[@]}]=$tmp
  9355.     done < <( eval compgen -f -X $xspec -- "\$(quote_readline "\$cur")" )
  9356.  
  9357.     COMPREPLY=( "${toks[@]}" )
  9358. }
  9359. list=( $( sed -ne '/^# START exclude/,/^# FINISH exclude/p' \
  9360.       $BASH_COMPLETION | \
  9361.     # read exclusion compspecs
  9362.     (
  9363.     while read line
  9364.     do
  9365.         # ignore compspecs that are commented out
  9366.         if [ "${line#\#}" != "$line" ]; then continue; fi
  9367.         line=${line%# START exclude*}
  9368.         line=${line%# FINISH exclude*}
  9369.         line=${line##*\'}
  9370.         list=( "${list[@]}" $line )
  9371.     done
  9372.     echo "${list[@]}"
  9373.     )
  9374.      ) )
  9375. # remove previous compspecs
  9376. if [ ${#list[@]} -gt 0 ]; then
  9377.     eval complete -r ${list[@]}
  9378.     # install new compspecs
  9379.     eval complete -F _filedir_xspec $filenames "${list[@]}"
  9380. fi
  9381. unset list
  9382.  
  9383. # source completion directory definitions
  9384. if [ -d $BASH_COMPLETION_DIR -a -r $BASH_COMPLETION_DIR -a \
  9385.      -x $BASH_COMPLETION_DIR ]; then
  9386.     for i in $BASH_COMPLETION_DIR/*; do
  9387.         [[ ${i##*/} != @(*~|*.bak|*.swp|\#*\#|*.dpkg*|.rpm*) ]] &&
  9388.             [ \( -f $i -o -h $i \) -a -r $i ] && . $i
  9389.     done
  9390. fi
  9391. unset i
  9392.  
  9393. # source user completion file
  9394. [ $BASH_COMPLETION != ~/.bash_completion -a -r ~/.bash_completion ] \
  9395.     && . ~/.bash_completion
  9396. unset -f have
  9397. unset UNAME RELEASE default dirnames filenames have nospace bashdefault \
  9398.       plusdirs
  9399.  
  9400. set $BASH_COMPLETION_ORIGINAL_V_VALUE
  9401. unset BASH_COMPLETION_ORIGINAL_V_VALUE
  9402.  
  9403. ###  Local Variables:
  9404. ###  mode: shell-script
  9405. ###  End:
  9406.